verkörperte Agenten
1.0.0
Dokumente : Dokumente
Beispiel für einen einfachen Roboteragenten:
Simulationsbeispiel mit SimplerEnv:
? Motor Agent mit OpenVLA:
⏺️ Datensatz auf einem Roboter aufzeichnen
? Support, Diskussion und Anleitungen :
Aktualisierungen:
28. August 2024, verkörperte Agenten v1.2
mbodied um sie auszuprobieren.30. Juni 2024, verkörperte Agenten v1.0 :
mbodied umbenannt.Embodied Agents ist ein Toolkit zur Integration großer multimodaler Modelle in bestehende Roboterstacks mit nur wenigen Codezeilen. Es bietet Konsistenz, Zuverlässigkeit und Skalierbarkeit und ist für jeden Beobachtungs- und Aktionsraum konfigurierbar.
Die Sample-Klasse ist ein Basismodell zum Serialisieren, Aufzeichnen und Bearbeiten beliebiger Daten. Es ist erweiterbar, flexibel und stark typisiert. Indem Sie Ihre Beobachtungs- oder Aktionsobjekte in die Sample-Klasse einschließen, können Sie ganz einfach Folgendes konvertieren:
Um mehr über alle Möglichkeiten mit verkörperten Agenten zu erfahren, schauen Sie sich die Dokumentation an
Sample oder Dicts in ein einzelnes Sample oder Dict pack und entsprechend unpack ?Sample unflatten , solange Sie ihr ein gültiges JSON-Schema zur Verfügung stellen? Zum Erstellen eines Beispiels muss lediglich ein Python-Wörterbuch mit der Sample -Klasse umschlossen werden. Darüber hinaus können sie aus Kwargs, Gym Spaces und Tensoren hergestellt werden, um nur einige zu nennen.
from mbodied . types . sample import Sample
# Creating a Sample instance
sample = Sample ( observation = [ 1 , 2 , 3 ], action = [ 4 , 5 , 6 ])
# Flattening the Sample instance
flat_list = sample . flatten ()
print ( flat_list ) # Output: [1, 2, 3, 4, 5, 6]
# Generating a simplified JSON schema
>> > schema = sample . schema ()
{ 'type' : 'object' , 'properties' : { 'observation' : { 'type' : 'array' , 'items' : { 'type' : 'integer' }}, 'action' : { 'type' : 'array' , 'items' : { 'type' : 'integer' }}}}
# Unflattening a list into a Sample instance
Sample . unflatten ( flat_list , schema )
>> > Sample ( observation = [ 1 , 2 , 3 ], action = [ 4 , 5 , 6 ])Die Sample-Klasse nutzt die leistungsstarken Funktionen von Pydantic zur Serialisierung und Deserialisierung und ermöglicht Ihnen eine einfache Konvertierung zwischen Sample-Instanzen und JSON.
# Serialize the Sample instance to JSON
sample = Sample ( observation = [ 1 , 2 , 3 ], action = [ 4 , 5 , 6 ])
json_data = sample . model_dump_json ()
print ( json_data ) # Output: '{"observation": [1, 2, 3], "action": [4, 5, 6]}'
# Deserialize the JSON data back into a Sample instance
json_data = '{"observation": [1, 2, 3], "action": [4, 5, 6]}'
sample = Sample . model_validate ( from_json ( json_data ))
print ( sample ) # Output: Sample(observation=[1, 2, 3], action=[4, 5, 6]) # Converting to a dictionary
sample_dict = sample . to ( "dict" )
print ( sample_dict ) # Output: {'observation': [1, 2, 3], 'action': [4, 5, 6]}
# Converting to a NumPy array
sample_np = sample . to ( "np" )
print ( sample_np ) # Output: array([1, 2, 3, 4, 5, 6])
# Converting to a PyTorch tensor
sample_pt = sample . to ( "pt" )
print ( sample_pt ) # Output: tensor([1, 2, 3, 4, 5, 6]) gym_space = sample . space ()
print ( gym_space )
# Output: Dict('action': Box(-inf, inf, (3,), float64), 'observation': Box(-inf, inf, (3,), float64))Weitere Informationen finden Sie unter sample.py.
Die Message-Klasse stellt einen einzelnen Vervollständigungsbeispielbereich dar. Dabei kann es sich um Text, ein Bild, eine Text-/Bildliste, ein Beispiel oder eine andere Modalität handeln. Die Message-Klasse ist für die Verarbeitung verschiedener Arten von Inhalten konzipiert und unterstützt verschiedene Rollen wie Benutzer, Assistent oder System.
Sie können eine Message auf vielfältige Weise erstellen. Sie können alle vom Backend von mbodi verstanden werden.
from mbodied . types . message import Message
Message ( role = "user" , content = "example text" )
Message ( role = "user" , content = [ "example text" , Image ( "example.jpg" ), Image ( "example2.jpg" )])
Message ( role = "user" , content = [ Sample ( "Hello" )])Die Backend-Klasse ist eine abstrakte Basisklasse für Backend-Implementierungen. Es stellt die grundlegende Struktur und die Methoden bereit, die für die Interaktion mit verschiedenen Backend-Diensten erforderlich sind, beispielsweise API-Aufrufe zum Generieren von Vervollständigungen basierend auf bestimmten Nachrichten. Informationen zur Implementierung verschiedener Backends finden Sie im Backend-Verzeichnis.
Agent ist die Basisklasse für verschiedene unten aufgeführte Agenten. Es bietet eine Vorlage zum Erstellen von Agenten, die mit einem Remote-Backend/Server kommunizieren und optional deren Aktionen und Beobachtungen aufzeichnen können.
Der Sprachagent kann eine Verbindung zu verschiedenen Backends oder Transformern Ihrer Wahl herstellen. Es umfasst Methoden zum Aufzeichnen von Gesprächen, zum Verwalten des Kontexts, zum Nachschlagen von Nachrichten, zum Vergessen von Nachrichten, zum Speichern von Kontext und zum Handeln basierend auf einer Anweisung und einem Bild.
Unterstützt nativ API-Dienste: OpenAI, Anthropic, vLLM, Ollama, HTTPX oder alle Gradio-Endpunkte. Weitere folgen!
So verwenden Sie OpenAI für Ihr Roboter-Backend:
from mbodied . agents . language import LanguageAgent
agent = LanguageAgent ( context = "You are a robot agent." , model_src = "openai" )So führen Sie eine Anweisung aus:
instruction = "pick up the fork"
response = robot_agent . act ( instruction , image )Der Sprachagent kann auch eine Verbindung zu vLLM herstellen. Angenommen, Sie betreiben einen vLLM-Server Mistral-7B unter 1.2.3.4:1234. Alles was Sie tun müssen ist:
agent = LanguageAgent (
context = context ,
model_src = "openai" ,
model_kwargs = { "api_key" : "EMPTY" , "base_url" : "http://1.2.3.4:1234/v1" },
)
response = agent . act ( "Hello, how are you?" , model = "mistralai/Mistral-7B-Instruct-v0.3" )Beispiel mit Ollama:
agent = LanguageAgent (
context = "You are a robot agent." , model_src = "ollama" ,
model_kwargs = { "endpoint" : "http://localhost:11434/api/chat" }
)
response = agent . act ( "Hello, how are you?" , model = "llama3.1" ) Motor Agent ähnelt Language Agent, gibt jedoch statt einer Zeichenfolge immer eine Motion zurück. Motor Agent wird im Allgemeinen von Robotertransformatormodellen angetrieben, z. B. OpenVLA, RT1, Octo usw. Einige kleine Modelle wie RT1 können auf Edge-Geräten ausgeführt werden. Allerdings kann es bei einigen, wie z. B. OpenVLA, schwierig sein, ohne Quantisierung zu laufen. Siehe OpenVLA-Agent und einen Beispiel-OpenVLA-Server
Diese Agenten interagieren mit der Umgebung, um Sensordaten zu sammeln. Sie geben immer einen SensorReading zurück, bei dem es sich um verschiedene Formen verarbeiteter sensorischer Eingaben wie Bilder, Tiefendaten oder Audiosignale handeln kann.
Derzeit haben wir:
Agenten, die die Sensorinformationen des Roboters verarbeiten.
Auto Agent wählt dynamisch den richtigen Agenten basierend auf der Aufgabe und dem Modell aus und initialisiert ihn.
from mbodied . agents . auto . auto_agent import AutoAgent
# This makes it a LanguageAgent
agent = AutoAgent ( task = "language" , model_src = "openai" )
response = agent . act ( "What is the capital of France?" )
# This makes it a motor agent: OpenVlaAgent
auto_agent = AutoAgent ( task = "motion-openvla" , model_src = "https://api.mbodi.ai/community-models/" )
action = auto_agent . act ( "move hand forward" , Image ( size = ( 224 , 224 )))
# This makes it a sensory agent: DepthEstimationAgent
auto_agent = AutoAgent ( task = "sense-depth-estimation" , model_src = "https://api.mbodi.ai/sense/" )
depth = auto_agent . act ( image = Image ( size = ( 224 , 224 ))) Alternativ können Sie auch die Methode get_agent in auto_agent verwenden.
language_agent = get_agent ( task = "language" , model_src = "openai" ) Das Modul „motion_controls“ definiert verschiedene Bewegungen zur Steuerung eines Roboters als Pydantic-Modelle. Sie sind auch eine Unterklasse von Sample und verfügen somit über alle oben erwähnten Funktionen von Sample . Diese Steuerungen decken eine Reihe von Aktionen ab, von einfachen Gelenkbewegungen bis hin zu komplexen Posen und vollständiger Robotersteuerung.
Sie können Ihre benutzerdefinierte Roboterhardware ganz einfach integrieren, indem Sie Robot in eine Unterklasse unterteilen. Sie müssen nur die Funktion do() implementieren, um Aktionen auszuführen (und einige zusätzliche Methoden, wenn Sie Datensätze auf dem Roboter aufzeichnen möchten). In unseren Beispielen verwenden wir einen Scheinroboter. Als Beispiel haben wir auch einen XArm-Roboter.
Das Aufzeichnen eines Datensatzes auf einem Roboter ist ganz einfach! Sie müssen lediglich die Methoden get_observation() , get_state() und prepare_action() für Ihren Roboter implementieren. Danach können Sie jederzeit einen Datensatz auf Ihrem Roboter aufzeichnen. Weitere Informationen finden Sie unter „examples/5_teach_robot_record_dataset.py“ und in diesem Colab:
from mbodied . robots import SimRobot
from mbodied . types . motion . control import HandControl , Pose
robot = SimRobot ()
robot . init_recorder ( frequency_hz = 5 )
with robot . record ( "pick up the fork" ):
motion = HandControl ( pose = Pose ( x = 0.1 , y = 0.2 , z = 0.3 , roll = 0.1 , pitch = 0.2 , yaw = 0.3 ))
robot . do ( motion )Der Datensatzrekorder ist ein Rekorder auf niedrigerer Ebene, mit dem Sie Ihr Gespräch und die Aktionen des Roboters in einem Datensatz aufzeichnen können, während Sie mit dem Roboter interagieren bzw. ihn unterrichten. Sie können für den Recorder einen beliebigen Beobachtungs- und Aktionsraum definieren. Weitere Informationen zu den Räumen finden Sie in der Turnhalle.
from mbodied . data . recording import Recorder
from mbodied . types . motion . control import HandControl
from mbodied . types . sense . vision import Image
from gymnasium import spaces
observation_space = spaces . Dict ({
'image' : Image ( size = ( 224 , 224 )). space (),
'instruction' : spaces . Text ( 1000 )
})
action_space = HandControl (). space ()
recorder = Recorder ( 'example_recorder' , out_dir = 'saved_datasets' , observation_space = observation_space , action_space = action_space )
# Every time robot makes a conversation or performs an action:
recorder . record ( observation = { 'image' : image , 'instruction' : instruction ,}, action = hand_control ) Der Datensatz wird unter ./saved_datasets gespeichert.
Die Replayer-Klasse dient zum Verarbeiten und Verwalten von Daten, die in von Recorder generierten HDF5-Dateien gespeichert sind. Es bietet eine Vielzahl von Funktionen, darunter das Lesen von Beispielen, das Erstellen von Statistiken, das Extrahieren einzigartiger Elemente und das Konvertieren von Datensätzen zur Verwendung mit HuggingFace. Der Replayer unterstützt auch das Speichern bestimmter Bilder während der Verarbeitung und bietet eine Befehlszeilenschnittstelle für verschiedene Vorgänge.
Beispiel für die Iteration durch einen Datensatz von Recorder mit Replayer:
from mbodied . data . replaying import Replayer
replayer = Replayer ( path = str ( "path/to/dataset.h5" ))
for observation , action in replayer :
...├─ assets/ ............. Images, icons, and other static assets
├─ examples/ ........... Example scripts and usage demonstrations
├─ resources/ .......... Additional resources for examples
├─ src/
│ └─ mbodied/
│ ├─ agents/ ....... Modules for robot agents
│ │ ├─ backends/ .. Backend implementations for different services for agents
│ │ ├─ language/ .. Language based agents modules
│ │ ├─ motion/ .... Motion based agents modules
│ │ └─ sense/ ..... Sensory, e.g. audio, processing modules
│ ├─ data/ ......... Data handling and processing
│ ├─ hardware/ ..... Hardware modules, i.e. camera
│ ├─ robot/ ........ Robot interface and interaction
│ └─ types/ ........ Common types and definitions
└─ tests/ .............. Unit testsWir freuen uns über Anliegen, Fragen und PRs. Weitere Informationen finden Sie im beitragenden Leitfaden.
