agentes encarnados
1.0.0
Documentos : documentos
Ejemplo de agente robot simple:
Ejemplo de simulación con SimplerEnv:
? Agente motor usando OpenVLA:
⏺️ Grabar conjunto de datos en un robot
? Soporte, discusión y procedimientos :
Actualizaciones:
28 de agosto de 2024, agentes incorporados v1.2
mbodied para probarlos.30 de junio de 2024, agentes incorporados v1.0 :
mbodied .Agentes incorporados es un conjunto de herramientas para integrar grandes modelos multimodales en pilas de robots existentes con solo unas pocas líneas de código. Proporciona consistencia, confiabilidad, escalabilidad y es configurable para cualquier espacio de observación y acción.
La clase Sample es un modelo base para serializar, registrar y manipular datos arbitrarios. Está diseñado para ser extensible, flexible y fuertemente tipado. Al envolver sus objetos de observación o acción en la clase Muestra, podrá convertir desde y hacia lo siguiente con facilidad:
Para obtener más información sobre todas las posibilidades con agentes incorporados, consulte la documentación.
pack una lista de Sample o Dicts en un solo Sample o Dict y unpack en consecuencia?unflatten cualquier estructura de Python en una clase Sample siempre que le proporcione un esquema json válido? Crear una muestra requiere simplemente envolver un diccionario de Python con la clase Sample . Además, se pueden crear a partir de kwargs, espacios de gimnasio y tensores, por nombrar algunos.
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 ])La clase Sample aprovecha las potentes funciones de Pydantic para la serialización y deserialización, lo que le permite convertir fácilmente entre instancias de Sample y 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))Consulte sample.py para obtener más detalles.
La clase Mensaje representa un espacio muestral de finalización única. Puede ser texto, imagen, una lista de texto/imágenes, muestra u otra modalidad. La clase Mensaje está diseñada para manejar varios tipos de contenido y admite diferentes roles, como usuario, asistente o sistema.
Puede crear un Message de formas versátiles. Todos ellos pueden ser entendidos por el backend de mbodi.
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" )])La clase Backend es una clase base abstracta para implementaciones de Backend. Proporciona la estructura básica y los métodos necesarios para interactuar con diferentes servicios de backend, como llamadas API para generar finalizaciones basadas en mensajes determinados. Consulte el directorio de backends sobre cómo se implementan los distintos backends.
Agente es la clase base para varios agentes que se enumeran a continuación. Proporciona una plantilla para crear agentes que pueden comunicarse con un servidor/backend remoto y, opcionalmente, registrar sus acciones y observaciones.
El Language Agent puede conectarse a diferentes backends o transformadores de su elección. Incluye métodos para grabar conversaciones, gestionar el contexto, buscar mensajes, olvidar mensajes, almacenar contexto y actuar en función de una instrucción y una imagen.
Admite de forma nativa servicios API: OpenAI, Anthropic, vLLM, Ollama, HTTPX o cualquier punto final de gradio. ¡Más próximamente!
Para utilizar OpenAI para el backend de su robot:
from mbodied . agents . language import LanguageAgent
agent = LanguageAgent ( context = "You are a robot agent." , model_src = "openai" )Para ejecutar una instrucción:
instruction = "pick up the fork"
response = robot_agent . act ( instruction , image )Language Agent también puede conectarse a vLLM. Por ejemplo, suponga que está ejecutando un servidor vLLM Mistral-7B en 1.2.3.4:1234. Todo lo que necesitas hacer es:
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" )Ejemplo usando 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 es similar a Language Agent pero en lugar de devolver una cadena, siempre devuelve un Motion . Motor Agent generalmente funciona con modelos de transformadores robóticos, es decir, OpenVLA, RT1, Octo, etc. Algunos modelos pequeños, como RT1, pueden ejecutarse en dispositivos periféricos. Sin embargo, algunos, como OpenVLA, pueden resultar difíciles de ejecutar sin cuantificación. Ver Agente OpenVLA y un servidor OpenVLA de ejemplo
Estos agentes interactúan con el entorno para recopilar datos de sensores. Siempre devuelven un SensorReading , que puede ser varias formas de información sensorial procesada, como imágenes, datos de profundidad o señales de audio.
Actualmente tenemos:
Agentes que procesan la información de los sensores del robot.
Auto Agent selecciona e inicializa dinámicamente el agente correcto según la tarea y el modelo.
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 ))) Alternativamente, también puedes usar el método get_agent en auto_agent.
language_agent = get_agent ( task = "language" , model_src = "openai" ) El módulo motion_controls define varios movimientos para controlar un robot como modelos Pydantic. También están subclasificados de Sample , por lo que poseen todas las capacidades de Sample como se mencionó anteriormente. Estos controles cubren una variedad de acciones, desde simples movimientos articulares hasta posturas complejas y control total del robot.
Puede integrar el hardware de su robot personalizado subclasificando Robot con bastante facilidad. Solo necesita implementar la función do() para realizar acciones (y algunos métodos adicionales si desea registrar un conjunto de datos en el robot). En nuestros ejemplos, utilizamos un robot simulado. También tenemos un robot XArm como ejemplo.
¡Registrar un conjunto de datos en un robot es muy fácil! Todo lo que necesita hacer es implementar los métodos get_observation() , get_state() y prepare_action() para su robot. Después de eso, puedes registrar un conjunto de datos en tu robot en cualquier momento que desees. Consulte ejemplos/5_teach_robot_record_dataset.py y esta colaboración: para obtener más detalles.
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 )Dataset Recorder es una grabadora de nivel inferior para grabar su conversación y las acciones del robot en un conjunto de datos mientras interactúa con el robot o le enseña. Puede definir cualquier espacio de observación y espacio de acción para el Grabador. Ver gimnasio para más detalles sobre espacios.
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 ) El conjunto de datos se guarda en ./saved_datasets .
La clase Replayer está diseñada para procesar y administrar datos almacenados en archivos HDF5 generados por Recorder . Proporciona una variedad de funcionalidades, que incluyen lectura de muestras, generación de estadísticas, extracción de elementos únicos y conversión de conjuntos de datos para usar con HuggingFace. El Replayer también permite guardar imágenes específicas durante el procesamiento y ofrece una interfaz de línea de comandos para diversas operaciones.
Ejemplo de iteración a través de un conjunto de datos de Recorder with 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 testsDamos la bienvenida a problemas, preguntas y relaciones públicas. Consulte la guía de contribución para obtener más información.
