agen yang diwujudkan
1.0.0
Dokumen : dokumen
Contoh Agen Robot Sederhana:
Contoh Simulasi dengan SimplerEnv:
? Agen Motor menggunakan OpenVLA:
⏺️ Rekam Dataset pada Robot
? Dukungan, Diskusi, dan Petunjuknya :
Pembaruan:
28 Agustus 2024, agen yang diwujudkan v1.2
mbodied untuk mencobanya.30 Juni 2024, agen yang diwujudkan v1.0 :
mbodied .agen yang diwujudkan adalah perangkat untuk mengintegrasikan model multi-modal besar ke dalam tumpukan robot yang ada hanya dengan beberapa baris kode. Ini memberikan konsistensi, keandalan, skalabilitas, dan dapat dikonfigurasi untuk ruang observasi dan tindakan apa pun.
Kelas Sample adalah model dasar untuk membuat serialisasi, merekam, dan memanipulasi data arbitrer. Ini dirancang agar dapat diperpanjang, fleksibel, dan diketik dengan kuat. Dengan menggabungkan objek observasi atau tindakan dalam kelas Sample, Anda akan dapat mengonversi ke dan dari objek berikut dengan mudah:
Untuk mempelajari lebih lanjut tentang semua kemungkinan dengan agen yang ada, lihat dokumentasinya
pack daftar Sample s atau Dicts ke dalam satu Sample atau Dict dan unpack sesuai dengan itu?unflatten struktur python apa pun ke dalam kelas Sample selama Anda menyediakan skema json yang valid? Membuat Sampel hanya memerlukan membungkus kamus python dengan kelas Sample . Selain itu, mereka dapat dibuat dari kwarg, Gym Spaces, dan Tensor.
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 ])Kelas Sample memanfaatkan fitur canggih Pydantic untuk serialisasi dan deserialisasi, memungkinkan Anda dengan mudah mengkonversi antara instance Sample dan 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))Lihat sample.py untuk detail selengkapnya.
Kelas Pesan mewakili ruang sampel penyelesaian tunggal. Bisa berupa teks, gambar, daftar teks/gambar, Contoh, atau modalitas lainnya. Kelas Pesan dirancang untuk menangani berbagai jenis konten dan mendukung berbagai peran seperti pengguna, asisten, atau sistem.
Anda dapat membuat Message dengan berbagai cara. Semuanya dapat dipahami oleh backend 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" )])Kelas Backend adalah kelas dasar abstrak untuk implementasi Backend. Ini menyediakan struktur dan metode dasar yang diperlukan untuk berinteraksi dengan layanan backend yang berbeda, seperti panggilan API untuk menghasilkan penyelesaian berdasarkan pesan yang diberikan. Lihat direktori backend tentang bagaimana berbagai backend diimplementasikan.
Agen adalah kelas dasar untuk berbagai agen yang tercantum di bawah. Ini menyediakan templat untuk membuat agen yang dapat berkomunikasi dengan backend/server jarak jauh dan secara opsional merekam tindakan dan pengamatan mereka.
Agen Bahasa dapat terhubung ke backend atau transformator berbeda pilihan Anda. Ini mencakup metode untuk merekam percakapan, mengelola konteks, mencari pesan, melupakan pesan, menyimpan konteks, dan bertindak berdasarkan instruksi dan gambar.
Mendukung layanan API secara asli: OpenAI, Anthropic, vLLM, Ollama, HTTPX, atau titik akhir gradio apa pun. Lebih banyak lagi yang akan datang!
Untuk menggunakan OpenAI pada backend robot Anda:
from mbodied . agents . language import LanguageAgent
agent = LanguageAgent ( context = "You are a robot agent." , model_src = "openai" )Untuk menjalankan instruksi:
instruction = "pick up the fork"
response = robot_agent . act ( instruction , image )Agen Bahasa juga dapat terhubung ke vLLM. Misalnya, Anda menjalankan server vLLM Mistral-7B pada 1.2.3.4:1234. Yang perlu Anda lakukan adalah:
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" )Contoh penggunaan 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 mirip dengan Language Agent tetapi alih-alih mengembalikan string, ia selalu mengembalikan Motion . Agen Motor umumnya ditenagai oleh model trafo robotik, yaitu OpenVLA, RT1, Octo, dll. Beberapa model kecil, seperti RT1, dapat berjalan di perangkat edge. Namun, beberapa, seperti OpenVLA, mungkin sulit dijalankan tanpa kuantisasi. Lihat Agen OpenVLA dan contoh server OpenVLA
Agen-agen ini berinteraksi dengan lingkungan untuk mengumpulkan data sensor. Mereka selalu mengembalikan SensorReading , yang dapat berupa berbagai bentuk input sensorik yang diproses seperti gambar, data kedalaman, atau sinyal audio.
Saat ini, kami memiliki:
agen yang memproses informasi sensor robot.
Agen Otomatis secara dinamis memilih dan menginisialisasi agen yang benar berdasarkan tugas dan model.
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 ))) Alternatifnya, Anda juga dapat menggunakan metode get_agent di auto_agent.
language_agent = get_agent ( task = "language" , model_src = "openai" ) Modul motion_controls mendefinisikan berbagai gerakan untuk mengendalikan robot sebagai model Pydantic. Mereka juga merupakan subkelas dari Sample , sehingga memiliki semua kemampuan Sample seperti yang disebutkan di atas. Kontrol ini mencakup berbagai tindakan, mulai dari gerakan sendi sederhana hingga pose kompleks dan kontrol robot penuh.
Anda dapat mengintegrasikan perangkat keras robot khusus Anda dengan membuat subkelas Robot dengan cukup mudah. Anda hanya perlu mengimplementasikan fungsi do() untuk melakukan tindakan (dan beberapa metode tambahan jika ingin merekam dataset pada robot). Dalam contoh kami, kami menggunakan robot tiruan. Kami juga memiliki robot XArm sebagai contoh.
Merekam dataset pada robot sangatlah mudah! Yang perlu Anda lakukan hanyalah mengimplementasikan metode get_observation() , get_state() , dan prepare_action() untuk robot Anda. Setelah itu, Anda dapat merekam dataset pada robot Anda kapan pun Anda mau. Lihat example/5_teach_robot_record_dataset.py dan colab ini: untuk detail selengkapnya.
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 )Perekam Kumpulan Data adalah perekam tingkat rendah untuk merekam percakapan Anda dan tindakan robot ke kumpulan data saat Anda berinteraksi dengan/mengajar robot. Anda dapat menentukan ruang observasi dan ruang tindakan apa pun untuk Perekam. Lihat gimnasium untuk detail lebih lanjut tentang ruang.
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 ) Kumpulan data disimpan ke ./saved_datasets .
Kelas Replayer dirancang untuk memproses dan mengelola data yang disimpan dalam file HDF5 yang dihasilkan oleh Recorder . Ini menyediakan berbagai fungsi, termasuk membaca sampel, menghasilkan statistik, mengekstraksi item unik, dan mengonversi kumpulan data untuk digunakan dengan HuggingFace. Replayer juga mendukung penyimpanan gambar tertentu selama pemrosesan dan menawarkan antarmuka baris perintah untuk berbagai operasi.
Contoh untuk melakukan iterasi melalui dataset dari Recorder dengan 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 testsKami menerima isu, pertanyaan, dan PR. Lihat panduan berkontribusi untuk informasi lebih lanjut.
