დაიწყეთ ასინქრონული ინფერენციის გაცნობა ჩვენი გაკვეთილის მეშვეობით. შედარება: თანმიმდევრული ინფერენცია (პირველი) ასინქრონულ ინფერენციასთან (მეორე). ხელახალი დაგეგმვისა და მჭიდრო მართვის მარყუჟის საშუალებით, ასინქრონული ინფერენცია იწვევს (1) აღდგენის მცდელობებს და (2) დავალების დასრულების დაახლოებით 2-ჯერ დაჩქარებას. თანმიმდევრული ინფერენცია აგრძელებს მიმდინარე მოქმედებათა ნაკრების შესრულებას ობიექტის აღების წარუმატებლობის შემდეგაც კი, მაშინ როცა ასინქრონულ ინფერენციას შეუძლია ახალი მოქმედებათა ნაკრების ხელახლა დაგეგმვა და შესრულება. ორივე სისტემა იყენებს ერთსა და იმავე პოლიტიკას! ასინქრონული ინფერენციით, ჩვენ ვყოფთ მოქმედების აღსრულებას მოქმედების პროგნოზირებისგან. ეს განსაკუთრებით მნიშვნელოვანია იმის გათვალისწინებით, რომ ამჟამად პოპულარული მოდელები, როგორიცაა [ACT], [OpenVLA], [PI0] და [SmolVLA], მიდრეკილნი არიან გამოიტანონ მოქმედებათა ნაკრებები (t-დან t+H-მდე) და არა ცალკეული მოქმედებები (t-ში) მოცემული დაკვირვების (ot) საფუძველზე. ამაში დარწმუნდით LeRobot-ის გამოყენებით ყველა ამ მოდელის გაშვებით. მოქმედებათა ნაკრებების თანმიმდევრული გამოყენება იწვევს (1) შეყოვნებებს შესრულების დროს, რაც გავლენას ახდენს დავალების შესრულების ხანგრძლივობაზე, და (2) რეაგირების ნაკლებობას, რაც განპირობებულია ფართოდ ღია მარყუჟით მოქმედებით. ასინქრონული ინფერენცია ამ ორივე შეზღუდვას ამცირებს მოქმედების პროგნოზირების მოქმედების აღსრულებისგან განცალკევებით. ჩვენ დავნერგეთ ასინქრონული ინფერენცია SmolVLA-ში და აღმოვაჩინეთ, რომ ის იწვევს დავალების დასრულების დროის დაახლოებით 2-ჯერ დაჩქარებას, დავალების წარმატების შედარებადი მაჩვენებლით. კერძოდ, ჩვენ შევქმენით 2-კომპონენტიანი სისტემა, სადაც პოლიტიკის ინფერენცია და მოქმედების აღსრულება ხორციელდება ორ სხვადასხვა პროცესში, შესაძლოა ორ სხვადასხვა მანქანაზე, რომლებიც ქსელის საშუალებით არიან დაკავშირებული: PolicyServer-სა და RobotClient-ს შორის კომუნიკაცია gRPC-ზეა დაფუძნებული, რაც გარანტიას იძლევა დაახლოებით 5-ჯერ უფრო სწრაფი მუშაობისა, ვიდრე შედარებადი REST API. ყოველივე ამის შედეგია რობოტი, რომელიც არასოდეს ელოდება ინფერენციას. ასინქრონული ინფერენციის ძირითადი მახასიათებლები: (1) კლიენტი აგზავნის პირველ დაკვირვებას ინფერენციისთვის, რის შემდეგაც მალევე იღებს მოქმედების პირველ ნაკრებს; (2) კლიენტი აგზავნის სხვა დაკვირვებას დასამუშავებლად, სანამ ის ჯერ კიდევ არ ამოწურავს მიმდინარე ნაკრებს; (3) კლიენტი იღებს განახლებულ მოქმედებათა ნაკრებს, რომელსაც ის აერთიანებს წინა, მიმდინარე ნაკრების დარჩენილ ნაწილებთან. დავუშვათ, რომ პოლიტიკა (π) მიმდინარე დაკვირვებას (ot) H რაოდენობის მომავალი მოქმედებების თანმიმდევრობად გარდაქმნის. ფორმალურად, π:O  ↦  A, At=(at, at+1, …at+H)=π(ot). ამდენად, ტრადიციული მართვის მარყუჟი შედგებოდა შემდეგი ნაბიჯებისგან: ნაბიჯი 2-ის განმავლობაში რობოტი უმოქმედოა. დაყოვნება იზრდება მოდელის ზომასთან ერთად (და მოდელები დროთა განმავლობაში სულ უფრო მოცულობითი ხდება) და მას შეუძლია სწრაფად გაუსწროს ურთიერთქმედების დროს (რაც, როგორც წესი, დაახლოებით 1/fps-ია), როგორც ეს ნაჩვენებია ქვემოთ მოცემულ ვიდეოში (ჩვენი Discord საზოგადოებიდან). ეს პირდაპირ იწვევს (1) შემცირებულ წარმადობას დავალების დასრულების დროის თვალსაზრისით — რობოტს უწევს ლოდინი, სანამ გამოითვლება მოქმედების შემდეგი ნაკრები — და (2) შემცირებულ რეაგირების უნარს, რაც გამოწვეულია (2.1) ფართოდ ღია მარყუჟით მოქმედებით, სანამ მოქმედებები ხელმისაწვდომია და (2.2) სრული უმოქმედობით მოქმედების შემდეგი ნაკრების მოლოდინში. (მარცხნივ) თანმიმდევრული ინფერენცია გამოყოფილი უმოქმედო პერიოდებით. (მარჯვნივ) მოქმედების შერჩევის დრო, რომელიც აჩვენებს პიკებს, როდესაც ინფერენცია გააქტიურებულია ლოკალური რიგის ამოწურვის გამო (ინფერენციის დაყოვნება დაახლოებით ~100 მილიწამია — დაახლოებით ~3 კადრი 30fps-ზე — ACT მოდელის გამოყენებით 2021 წლის MacBook Pro-ზე). ჩვენი სისტემა აშორებს უმოქმედო პერიოდს გამოთვლისა და შესრულების გადაფარვით: მთავარი იდეა ისაა, რომ რობოტმა უკვე იცის რა უნდა გააკეთოს მომდევნო რამდენიმე ნაბიჯისთვის, ასე რომ მას შეუძლია განაგრძოს მოძრაობა, სანამ სერვერზე გამოითვლება ახალი მოქმედებები. ასინქრონული ინფერენცია დროულად გადაფარავს მიმდინარე მოქმედებათა ნაკრების შესრულებას მომდევნო ნაკრების გამოთვლასთან, ამ ორი პროცესის განცალკევებით, შესაძლოა მათი სრულიად განსხვავებულ, ქსელის საშუალებით დაკავშირებულ მანქანებზე გაშვებით. ეს იწვევს უფრო მჭიდრო მართვის მარყუჟს და რობოტს, რომელიც არასოდეს ელოდება ინფერენციას. თავის მხრივ, ეს იწვევს დავალების დასრულების დროის დაახლოებით 2-ჯერ დაჩქარებას დავალების წარმატების შედარებადი მაჩვენებლით, და უფრო ადაპტირებულ კონტროლს, რომელიც გამომდინარეობს უფრო მჭიდრო მარყუჟიდან (იხილეთ ვიდეო ქვემოთ). იმის გამო, რომ gRPC დაფუძნებულია HTTP/2-ზე და იყენებს ოქმის ბუფერებს, ის უზრუნველყოფს დაბალი შეყოვნების ბინარულ შეტყობინებებს და ორმხრივ ნაკადებს, რაც, თავის მხრივ, გვეხმარება უფრო მჭიდრო მართვის მარყუჟისა და 100 მილიწამზე ნაკლები ორმხრივი შეყოვნების შენარჩუნებაში (ჩვენს ლოკალურ ქსელში, SmolVLA-ს NVIDIA RTX 4090-ზე განთავსებისას). RobotClient მუშაობს ბორტზე და დაკვირვებებს აგზავნის PolicyServer-ზე gRPC-ის საშუალებით. PolicyServer ამზადებს მიღებულ დაკვირვებებს ინფერენციისთვის და RobotClient-ს უბრუნებს მოქმედების ნაკრებს. კლიენტის პერსპექტივიდან, დაკვირვებები სერვერზე გადაიცემა ლოკალური რიგის სტატუსის მიხედვით. შემომავალი ნაკრებები გაერთიანებულია ამჟამად არსებული მოქმედებათა რიგის გადაფარულ ნაწილებზე. RobotClient ინარჩუნებს ლოკალურ მოქმედებათა რიგს და მიჰყვება მარტივ, მაგრამ ეფექტურ სტრატეგიას: აგზავნის ახალ დაკვირვებას, როდესაც რიგის სიგრძე ეცემა კონფიგურირებადი ზღვრის ქვემოთ (SmolVLA-ის პ-ში მითითებული g).