เลเยอร์ข้อมูลใหม่สำหรับการเรียนรู้ของหุ่นยนต์

Physical AI จะเปลี่ยนโฉมอุตสาหกรรมต่างๆ ในโลกกายภาพ แต่หุ่นยนต์ยังขาดเลเยอร์ข้อมูลที่รวมเป็นหนึ่งเดียวซึ่งจำเป็นต่อการวนซ้ำด้วยความเร็วที่ AI สมัยใหม่ต้องการ ความท้าทายหลักคือการเรียนรู้ของหุ่นยนต์ทำงานบนข้อมูลทางกายภาพ: สตรีมข้อมูลแบบหลายอัตราและหลายรูปแบบที่ผูกกับเวลา พื้นที่ และการฝังตัว โครงสร้างพื้นฐานที่มีอยู่ส่วนใหญ่สร้างขึ้นสำหรับข้อมูลบนเว็บและไม่สามารถจัดการกับคุณสมบัติเหล่านี้ได้ดีนัก

ที่ @rerundotio เรากำลังสร้างเลเยอร์ข้อมูลแบบรวมสำหรับข้อมูลทางกายภาพ เพื่อช่วยให้ทีมงานฝึกฝนและส่งมอบความชาญฉลาดสำหรับโลกแห่งความจริง

การเปิดตัวครั้งใหญ่ที่สุดของ Rerun

Rerun เป็นที่รู้จักในด้านการแสดงภาพข้อมูลอนุกรมเวลาแบบหลายรูปแบบ ในช่วงปีครึ่งที่ผ่านมา เราได้สร้างส่วนอื่นๆ ของเลเยอร์ข้อมูลแบบรวมอย่างเงียบๆ เพื่อรองรับเส้นทางทั้งหมดตั้งแต่การรวบรวมจนถึงการฝึกฝน ด้วย การเปิดตัว Rerun SDK 0.32 ความสามารถเหล่านั้นกำลังจะมาสู่โอเพนซอร์ส!

นี่คือการเปิดตัวครั้งใหญ่ที่สุดนับตั้งแต่ Rerun ถูกเปิดเป็นโอเพนซอร์สเมื่อสามปีที่แล้ว และแสดงถึงการขยายขอบเขตของงานที่คุณสามารถทำได้กับ Rerun อย่างมาก

เรากำลังทำให้รูปแบบไฟล์มีความเสถียร และเพิ่มชุด API การอ่านและเขียนระดับต่ำใหม่สำหรับไฟล์ เรากำลังเพิ่ม API ใหม่สำหรับจัดการกับชิ้นส่วนข้อมูลของ Rerun ที่ออกแบบมาสำหรับการจัดการและทำให้ข้อมูลหุ่นยนต์จริงเป็นมาตรฐาน เรากำลังขยายการรองรับข้อความ MCAP และ ROS 2 เพื่อให้ประสบการณ์การใช้งานทันทีดีขึ้น เรากำลังเพิ่ม UI การตรวจสอบชุดข้อมูลใหม่เพื่อให้การตรวจสอบชุดข้อมูลฝึกฝนเร็วขึ้นมาก เซิร์ฟเวอร์แคตตาล็อกโอเพนซอร์สตอนนี้สามารถจัดทำดัชนีไฟล์ .rrd บนดิสก์ เพื่อให้คุณหรือเอเจนต์ของคุณสามารถเขียนคำค้นหาทั่วไปในไดเรกทอรีของการบันทึกข้อมูลหุ่นยนต์ได้ บนพื้นฐานเดียวกันนั้น เรายังปล่อยตัวโหลดข้อมูล PyTorch เพื่อให้คุณสามารถฝึกโมเดลหุ่นยนต์บนไฟล์ .rrd ได้โดยตรง โดยไม่ต้องส่งออกไปยังรูปแบบเฉพาะสำหรับการฝึกฝน

ระบบนิเวศของหุ่นยนต์ขาดกรอบงานแบบรวมที่ยืดหยุ่นพอที่จะรองรับวงจรชีวิตทั้งหมดของข้อมูลการเรียนรู้ของหุ่นยนต์ ด้วย 0.32 รากฐานนั้นกำลังเกิดขึ้น

นอกเหนือจากการเปิดตัวโอเพนซอร์สครั้งใหญ่นี้ เรายังประกาศ Rerun Hub ซึ่งเป็นแคตตาล็อกข้อมูลเชิงพาณิชย์และเอนจินจัดเก็บข้อมูลของเรา Rerun Hub อยู่ในช่วงพรีวิวส่วนตัว และขยาย Rerun SDK ไปยังชุดข้อมูลที่ backed โดย object storage โดยให้แคตตาล็อกและเลเยอร์การเข้าถึงร่วมกันสำหรับการแปลง การค้นหา การแสดงภาพ และการสตรีมข้อมูลหุ่นยนต์ในขนาดที่ใหญ่ขึ้นมาก ในขณะที่ยังคงรักษาโมเดลข้อมูลและ API เดียวกัน

ใช้ Rerun Hub หากความทะเยอทะยานของคุณคือการปรับขนาดข้อมูลให้เกินกว่าที่เครื่องท้องถิ่นของคุณจะรองรับได้ - ในขณะที่เคลื่อนที่อย่างรวดเร็ว! หากคุณเป็นทีมที่สร้างผลิตภัณฑ์เกี่ยวกับการเรียนรู้ของหุ่นยนต์และกำลังคิดเกี่ยวกับเลเยอร์ข้อมูลของคุณ ติดต่อเรา

ส่วนที่เหลือของโพสต์นี้มีสองส่วน ส่วนแรกคือข้อมูลเบื้องต้นเกี่ยวกับสถาปัตยกรรมข้อมูลที่เราเชื่อว่า Physical AI ต้องการเพื่อปรับขนาด ส่วนที่สองคือการทัวร์ชมความสามารถใหม่ใน Rerun SDK 0.32 ที่นำสถาปัตยกรรมนั้นไปใช้จริง

การเรียนรู้ของหุ่นยนต์ต้องการเลเยอร์ข้อมูลที่สร้างขึ้นโดยเฉพาะสำหรับข้อมูลทางกายภาพ

ตามที่ระบุไว้ใน \The Data Layer Tax for Robot Learning\ แรงเสียดทานส่วนใหญ่ที่ทำให้ความก้าวหน้าของ Physical AI ช้าลงมาจากการพยายามบังคับข้อมูลทางกายภาพผ่านโครงสร้างพื้นฐานที่ออกแบบมาสำหรับซอฟต์แวร์ดั้งเดิมและงานวิเคราะห์ สิ่งที่จำเป็นคือเลเยอร์ข้อมูลที่สร้างขึ้นสำหรับข้อมูลแบบหลายอัตราและหลายรูปแบบ ที่รองรับทุกสิ่งที่คุณต้องการเพื่อวนซ้ำความชาญฉลาดของหุ่นยนต์ ตั้งแต่การรวบรวมจนถึงการฝึกฝนและการปรับใช้

Coding agents หมายถึงผู้ใช้ต้องการควบคุมเลเยอร์การคำนวณและแอปพลิเคชันอย่างเต็มที่

เพื่อรองรับเวิร์กโฟลว์ทั้งหมดของการรวบรวม การทำให้เป็นมาตรฐาน การประมวลผลภายหลัง การคัดเลือก และการฝึกฝน ทีมงานต้องการเครื่องมือและงานคำนวณที่หลากหลาย เครื่องมือและงานเหล่านั้นสามารถเข้ารหัสวิธีการเฉพาะที่ทีมงานดำเนินการหรือเทคนิคที่พวกเขาใช้เพื่อขับเคลื่อนคุณภาพข้อมูลในขนาดใหญ่ ซึ่งทำให้เป็นพื้นที่สำคัญของความแตกต่างที่ทีมงานต้องเป็นเจ้าของ

Coding agents ทำให้ทีมงานสามารถออกแบบเครื่องมือและงานคำนวณเหล่านี้ได้ตามที่ต้องการมากขึ้นเรื่อยๆ ตราบใดที่พวกเขามีการควบคุมในระดับโค้ด ด้วยเหตุนี้ ทีมงานน้อยมากที่จะยอมรับการไม่มีการควบคุมนั้น นั่นคือเหตุผลที่ Rerun SDK เป็นโอเพนซอร์สอย่างสมบูรณ์และออกแบบมาเป็นกรอบงานที่คุณสามารถสร้างต่อยอดได้ ไม่ใช่แพลตฟอร์ม SaaS ที่มีกำแพงล้อมรอบ แม้แต่ตัว viewer ก็ออกแบบมาเป็นไลบรารีเพื่อให้คุณไม่ติดขัด Rerun ให้ความสำคัญกับโค้ดเป็นอันดับแรกมาโดยตลอด และเรากำลังเพิ่มความพยายามเป็นสองเท่าเพื่อให้ใช้งานกับเอเจนต์ได้ง่ายยิ่งขึ้น ซึ่งรวมถึงงานที่กำลังจะเกิดขึ้นเกี่ยวกับการเรนเดอร์แบบไม่มีหัวและการนำทาง viewer เพื่อช่วยให้เอเจนต์เห็นข้อมูลทางกายภาพเหมือนมนุษย์

ทีมงานส่วนใหญ่กำลังสร้างแอปพลิเคชันเฉพาะกิจและสคริปต์ประมวลผลที่ปรับแต่งให้เหมาะกับเวิร์กโฟลว์ของตนเองอยู่แล้ว หากไม่ได้สร้างบนรากฐานที่มั่นคง คุณจะลงเอยด้วยชิ้นส่วนแนวตั้งที่ยากต่อการทำความเข้าใจและไม่สามารถประกอบกันได้ดี ซึ่งจำกัดการเพิ่มผลผลิต

เลเยอร์ข้อมูลต้องจัดการส่วนที่ยากของการใช้ข้อมูลทางกายภาพขนาดใหญ่

ความสามารถหลักที่จำเป็นในการรองรับเส้นทางข้อมูลทั้งหมดตั้งแต่การรวบรวมจนถึงโมเดลคือ การแสดงภาพ การค้นหาเชิงวิเคราะห์ การแปลง และการฝึกฝน ความสามารถทั้งหมดเหล่านี้ต้องจัดการกับข้อมูลแบบหลายอัตราและหลายรูปแบบที่อาจมีความหมายทางหุ่นยนต์ เช่น ความสัมพันธ์ 3D หรือรูปร่าง เพื่อหลีกเลี่ยงข้อบกพร่องและข้อมูลที่ไม่สอดคล้องกัน คุณต้องการจัดการกับรายละเอียดปลีกย่อยของข้อมูลประเภทนี้อย่างสม่ำเสมอทุกที่ที่ใช้ ตัวอย่างเช่น การจัดตำแหน่งเวลาและการแปลง 3D ควรทำงานอย่างสม่ำเสมอในการประมวลผลล่วงหน้า การค้นหา การแสดงภาพ และการตรวจสอบชุดข้อมูล

เพื่อให้ง่ายต่อการวนซ้ำทั้งในวงจรการทดลองข้อมูลและเครื่องมือที่ขับเคลื่อนมัน คุณต้องการสร้างบนเลเยอร์ข้อมูลแบบรวมเดียวที่ทำให้การส่งต่อข้อมูลเป็นเรื่องง่ายและแอปพลิเคชันที่อยู่ด้านบนนั้นเรียบง่าย นั่นหมายความว่าเลเยอร์ข้อมูลต้องยืดหยุ่นพอที่จะจัดการกับข้อกำหนดจากความสามารถหลักของแอปพลิเคชันและการคำนวณทั้งหมด ตัวอย่างเช่น การแสดงภาพและการคำนวณทั้งคู่ต้องการการเข้าถึงแบบสุ่มอย่างรวดเร็วของอนุกรมเวลาแบบหลายรูปแบบ ในขณะที่การค้นหาเชิงวิเคราะห์ต้องการการสแกนคอลัมน์อย่างมีประสิทธิภาพ และทั้งการประมวลผลภายหลังขนาดใหญ่ (CPU) และการฝึกฝน (GPU) ต้องการการสตรีมข้อมูลแบบขนานที่มีแบนด์วิดท์สูง

ข้อมูลทางกายภาพทำงานแตกต่างจากข้อมูลบนเว็บและธุรกิจโดยพื้นฐาน ซึ่งหมายความว่าได้ประโยชน์จากสิ่งที่เป็นนามธรรมในการจัดเก็บและการค้นหาที่แตกต่างกัน

หน่วยจัดเก็บหลักสำหรับข้อมูลทางกายภาพคือ chunk ของคอลัมน์

ข้อมูลทางกายภาพมีลักษณะที่แตกต่างสองประการ:

ประการแรกคือเป็นแบบหลายอัตรา: เซ็นเซอร์ต่างกันจะบันทึกข้อมูลที่ความถี่ต่างกันอย่างมาก GPS อาจอยู่ที่ 1-10Hz, กล้องที่ 10-30Hz, มุมข้อต่อที่ 100-200Hz, และ IMU ที่ 1kHz ในการประมวลผลภายหลัง คุณอาจคำนวณ semantic embeddings สำหรับทุกๆ 10 เฟรมของกล้อง หรือคำอธิบายฉากที่จุดเริ่มต้นและสิ้นสุดของแต่ละตอน

ประการที่สองคือเป็นแบบหลายรูปแบบ: เซ็นเซอร์ต่างกันบันทึกข้อมูลที่มีขนาดต่างกันอย่างมาก IMU และ GPS ต้องการเพียงไม่กี่ไบต์เพื่อเข้ารหัสตัวเลขสองสามตัว ในขณะที่กล้อง RGB สามารถใช้หลาย MB สำหรับแต่ละเฟรมภาพ

หากคุณจัดเก็บการบันทึกข้อมูลหุ่นยนต์ในตารางที่หนึ่งแถวแสดงถึงการประทับเวลา และหนึ่งคอลัมน์แสดงถึงสตรีมข้อมูล แง่มุมแบบหลายอัตราจะทำให้ตารางนี้เบาบางมาก โดยทั่วไปแล้วสำหรับแถวใดๆ คอลัมน์ส่วนใหญ่มักจะว่างเปล่า แง่มุมแบบหลายรูปแบบของข้อมูลนำไปสู่ความไม่สมดุลของหน่วยความจำขนาดใหญ่ เนื่องจากแถวเดียวอาจมีเซลล์ที่มีขนาดแตกต่างกันตามลำดับความสำคัญ โครงสร้างพื้นฐานข้อมูลแบบตารางที่มีอยู่จัดการกับการรวมกันนี้ได้แย่มาก

ข้อมูลแบบหลายอัตราและหลายรูปแบบควรถูกจัดเก็บใน chunks ที่แต่ละ chunk เก็บชุดย่อยของแถวและคอลัมน์ของชุดข้อมูล ความสามารถในการวางตัวอย่าง IMU หนึ่งล้านตัวอย่างใน chunk หนึ่งและแพ็กเก็ตวิดีโอเพียงไม่กี่ชุดในอีก chunk หนึ่งช่วยให้คุณแก้ปัญหาทั้งความเบาบางและความไม่สมดุลของหน่วยความจำ

ภายใน chunk การจัดเก็บแบบเรียงคอลัมน์จะปรับให้เหมาะสมสำหรับการบีบอัดที่ดีขึ้นและการสแกนคอลัมน์ ในขณะที่การจัดเก็บแบบเรียงแถวจะปรับให้เหมาะสมสำหรับการเขียนที่ง่าย

ที่ Rerun เราเชื่อว่า column chunks แสดงถึงการแลกเปลี่ยนที่ดีที่สุดสำหรับระบบข้อมูลการเรียนรู้ของหุ่นยนต์ และเราได้กำหนดมาตรฐานสถาปัตยกรรมของเราให้มี column chunks เป็นสิ่งที่เป็นนามธรรมในการจัดเก็บหลัก

รูปแบบไฟล์ .rrd ของ Rerun สร้างขึ้นรอบๆ column chunks

รูปแบบไฟล์ดั้งเดิมของ Rerun, .rrd, คือการแสดงบนดิสก์ของสิ่งที่เป็นนามธรรมของ column chunk ภายใน แต่ละ column chunk ถูกเข้ารหัสเป็น Apache Arrow record batch พร้อมกับข้อมูลเมตาเชิงความหมายที่อธิบายว่าควรตีความข้อมูลอย่างไร Apache Arrow เป็นมาตรฐานอุตสาหกรรมสำหรับวิทยาศาสตร์ข้อมูล และการใช้ Arrow หมายความว่าเรามีเส้นทาง zero-copy ที่รวดเร็วไปยัง DataFusion, Pandas และ Polars

ข้อมูลเมตาในแต่ละ chunk ประกอบด้วยข้อมูลเชิงความหมายเกี่ยวกับวิธีการตีความข้อมูล ("นี่คือเซ็นเซอร์ IMU, นี่คือ GPS, …") เพื่อให้สามารถนำผ่านไปป์ไลน์การประมวลผลและยังคงถูกตีความและแสดงภาพโดยอัตโนมัติ

column chunks ที่เข้ารหัสแล้วจะถูกห่อหุ้มในข้อความ protobuf และต่อกันเพื่อสร้างไฟล์ .rrd ส่วนท้ายที่ส่วนท้ายของไฟล์ชี้ไปยังดัชนี ทำให้สามารถเข้าถึงแต่ละ chunk แบบสุ่มได้อย่างรวดเร็วโดยไม่ต้องสแกนไฟล์ทั้งหมด

การเปรียบเทียบกับรูปแบบอื่นๆ

Apache Parquet เป็นรูปแบบบนดิสก์แบบเรียงคอลัมน์ มักใช้ร่วมกับ Arrow โดยจัดระเบียบข้อมูลเป็น row groups แต่ไม่เหมือน chunks ใน .rrd กลุ่มเหล่านี้ไม่สามารถทับซ้อนกันได้: แต่ละ row group ประกอบด้วยคอลัมน์ทั้งหมดในช่วงแถวที่หนาแน่น ทำให้ไม่เหมาะกับข้อมูลหุ่นยนต์แบบหลายอัตราและหลายรูปแบบ คุณสามารถเพิ่มแถวใหม่ได้ แต่ไม่สามารถเพิ่มคอลัมน์ใหม่ได้ (ไม่มี schema evolution)

MCAP เป็นรูปแบบสำหรับบันทึกบันทึกหุ่นยนต์บนหุ่นยนต์ของคุณ ออกแบบมาให้เขียนได้รวดเร็วและยืดหยุ่น มีความเข้ากันได้กับ ROS ที่แข็งแกร่ง อย่างไรก็ตาม โดยพื้นฐานแล้วเป็นรูปแบบคอนเทนเนอร์ของข้อความทึบแสง (เข้ารหัสด้วย JSON, protobuf, CBOR ฯลฯ) และไม่ได้รับการปรับให้เหมาะสมสำหรับการค้นหาเชิงวิเคราะห์แบบเรียงคอลัมน์ การสแกนขนาดใหญ่และการ join ก็ช้าเช่นกัน เนื่องจากคุณต้องถอดรหัสแต่ละข้อความ

Lance เป็นรูปแบบใหม่ สร้างขึ้นอย่างชัดเจนสำหรับข้อมูลหลายรูปแบบและการเข้าถึงแบบสุ่ม (ซึ่งสำคัญมากสำหรับการฝึกฝน) ไม่เหมือน Parquet รองรับ schema evolution อย่างไรก็ตาม ชุดข้อมูล Lance ยังคงเป็นกองแนวตั้งของ fragments ที่เรียงแถว ดังนั้นสตรีมแบบหลายอัตราจะพองตัวด้วย nulls

NCore เป็นรูปแบบใหม่จาก Nvidia สร้างขึ้นสำหรับการสร้างใหม่ทางประสาท รองรับหลายอัตราโดยธรรมชาติผ่านการประทับเวลาต่อคอมโพเนนต์ และการจัดตำแหน่งเชิงพื้นที่ผ่าน pose graph อย่างไรก็ตาม schema เป็นแบบปิด (คอมโพเนนต์เซ็นเซอร์ตามบัญญัติ ไม่ใช่ข้อมูลที่ผู้ใช้กำหนดเอง) เป็นแบบ Zarr-based ไม่ใช่ Arrow-native และไม่ได้สร้างมาเพื่อรองรับเอนจินการค้นหา SQL / dataframe ทั่วไป

ทุกฟีเจอร์ที่ทีมของคุณต้องการซึ่งรูปแบบไฟล์ไม่มีให้ หมายถึงไปป์ไลน์อีกอันที่ต้องซิงค์และเครื่องมือเพิ่มเติมที่ต้องเรียนรู้เพื่อให้ทีมของคุณประสบความสำเร็จ รูปแบบของ Rerun เป็นตัวเลือกเดียวที่สามารถรองรับทุกกรณีการใช้งานที่จำเป็นในการเปลี่ยนการบันทึกหุ่นยนต์ให้เป็นความชาญฉลาด ช่วยให้คุณเก็บข้อมูลที่การประทับเวลาดั้งเดิม ในขณะที่ยังคงสามารถค้นหาและดูจากแหล่งข้อมูลเดียวกัน และสตรีมไปยังการฝึกฝน มีโครงสร้างเพียงพอที่จะสร้างระบบข้อมูลแบบรวมบนนั้น แต่ยืดหยุ่นพอที่จะปรับให้เหมาะสมสำหรับรูปแบบการอ่านและการเขียนที่แตกต่างกัน

เลเยอร์การจัดทำดัชนี schema และข้อมูลเมตาบน column chunks ช่วยลดความซับซ้อนในการใช้ข้อมูลทางกายภาพในขนาดใหญ่

การสแกน chunks ทั้งหมดในชุดข้อมูลเพื่อวิเคราะห์สัญญาณเดียวจะปรับขนาดได้ไม่ดีแม้สำหรับชุดข้อมูลขนาดเล็ก ดังนั้นเพื่อใช้ chunks อย่างมีประสิทธิภาพ คุณต้องมีเลเยอร์ข้อมูลเมตาและการจัดทำดัชนีที่สามารถช่วยค้นหา chunks ที่เหมาะสมสำหรับการค้นหาใดๆ ซึ่งดูคล้ายกับรูปแบบ data lakehouse แบบคลาสสิก ในกรณีของเรา ชุดข้อมูลหรือการบันทึกเดียวประกอบด้วย chunks ที่แตกต่างกันซึ่งไม่มี schema เดียวกัน เครื่องมือประมวลผลข้อมูลแบบคลาสสิกถูกสร้างขึ้นสำหรับการจัดการกับตารางที่มี schema ที่สม่ำเสมอ เลเยอร์การจัดทำดัชนีและข้อมูลเมตาแบบ lakehouse สำหรับข้อมูลทางกายภาพจึงต้องติดตาม schema แต่ละอันเหล่านี้ด้วย เพื่อให้สามารถสร้าง schema ที่รวมกันของสตรีมใดๆ ได้ทันที เพื่อให้เครื่องมือข้อมูลแบบคลาสสิกสามารถทำงานกับมันได้ ตัวอย่างเช่น หากคุณอัปเกรด IMU ของคุณเป็นรุ่นที่เผยแพร่ข้อมูลสนามแม่เหล็กในข้อความ การเพิ่มนี้จะเข้ากันได้กับ IMU รุ่นเก่าของคุณที่ไม่มีฟิลด์นี้ ไม่จำเป็นต้องเขียนข้อมูลประวัติใหม่เพื่อความเข้ากันได้

Column chunks ที่จับคู่กับการจัดทำดัชนีที่มีประสิทธิภาพช่วยให้คุณดึงข้อมูลที่คุณต้องการได้อย่างแม่นยำ โดยไม่ต้องจ่ายค่าปรับสำหรับสตรีมที่ไม่เกี่ยวข้องที่จัดเก็บไว้ข้างๆ คุณไม่ต้องเลือกระหว่างการทำให้การดำเนินการทั่วไปรวดเร็วและการสามารถไล่ตามข้อบกพร่องที่หายาก เพราะคุณส่งออกข้อมูลทั่วไปไปยังคลังข้อมูลแยกต่างหาก

นอกเหนือจากประโยชน์ด้านประสิทธิภาพแล้ว เลเยอร์นี้ช่วยให้เราสามารถทำให้ไฟล์เป็นนามธรรมและนำเสนอ API ที่รวมเป็นหนึ่งสำหรับผู้ใช้ข้อมูลทางกายภาพทั้งหมดในเลเยอร์ด้านบน บ่อยครั้งที่ข้อมูลหุ่นยนต์ถูกจัดเก็บในไฟล์เดียวและการสอบเทียบในอีกไฟล์หนึ่ง การทำให้รายละเอียดการใช้งานเหล่านี้เป็นนามธรรมเป็นส่วนสำคัญในการลดแรงเสียดทานของข้อมูลและทำให้เลเยอร์การคำนวณและแอปพลิเคชันง่ายขึ้น

การประมวลผลและการฝึกฝนขนาดใหญ่ต้องการการสตรีมแบบเลือกโดยตรงจาก object storage

ชุดข้อมูลการเรียนรู้ของหุ่นยนต์สามารถมีขนาดใหญ่มากอยู่แล้ว และจะใหญ่ขึ้นอีกมากเมื่อทีมงานปฏิบัติตามกฎการปรับขนาดเพื่อให้ได้โมเดลที่มีความสามารถมากขึ้นเรื่อยๆ ในการประมวลผลข้อมูลขนาดนี้ คุณมักจะต้องกระจายงานไปยัง CPU จำนวนมากสำหรับการประมวลผลภายหลังหรือ GPU สำหรับการฝึกฝน ในกรณีเหล่านี้ สิ่งสำคัญคือปริมาณงานข้อมูลสามารถปรับขนาดตามความต้องการของการคำนวณนี้

ทั้งเพื่อเพิ่มประสิทธิภาพสูงสุดและลดต้นทุนการส่งออก คุณต้องการให้การคำนวณทำงานใกล้กับข้อมูล ในเวลาเดียวกัน การคำนวณ GPU อาจหายาก ดังนั้นหลายทีมจึงลงเอยด้วยการเช่าในสถานที่ต่างๆ เมื่อเวลาผ่านไป ปัจจัยทั้งหมดเหล่านี้หมายความว่าคุณต้องการแยกการจัดเก็บออกจากบริการที่จัดการการจัดทำดัชนีและข้อมูลเมตา

ใน Rerun การค้นหาเริ่มต้นจาก Rerun SDK ที่สอบถาม Rerun Hub ซึ่งรับผิดชอบในการรู้ว่า chunks ใดที่จำเป็นในการแก้ไขการค้นหา ขึ้นอยู่กับการตั้งค่า SDK จะขอ chunks ผ่านพร็อกซีที่แคชไว้ใน Rerun Hub หรือช่วงไบต์บน object storage ซึ่งช่วยให้มี API การเข้าถึงที่เรียบง่าย การสตรีม chunks แบบเลือก และแบนด์วิดท์การสตรีมสูงสุดจาก object storage พื้นฐาน

Rerun SDK 0.32 คือชุดเครื่องมือข้อมูลแบบรวมสำหรับการเรียนรู้ของหุ่นยนต์

Rerun 0.32 เป็นการเปิดตัวครั้งใหญ่ที่สุดนับตั้งแต่เปิดเป็นโอเพนซอร์สในเดือนกุมภาพันธ์ 2023 โดยขยายกรณีการใช้งานจริงของ SDK จากการบันทึก การแสดงภาพ และการค้นหาที่ง่ายขึ้น ไปจนถึงเส้นทางข้อมูลทั้งหมดตั้งแต่การรวบรวมจนถึงการฝึกฝน ต่อไปนี้คือการทัวร์ชมฟีเจอร์ใหม่ที่เน้นการขยายนี้ ตรวจสอบ บันทึกการเปิดตัว สำหรับรายละเอียดเพิ่มเติม

รูปแบบไฟล์ที่เสถียรพร้อม Python APIs ระดับ chunk

ใน Rerun 0.23 เราได้ประกาศความเข้ากันได้ย้อนหลังแบบเวอร์ชันต่อเวอร์ชันสำหรับรูปแบบไฟล์ .rrd ของ Rerun ในทางปฏิบัติ เราไม่เคยทำลายความเข้ากันได้ระหว่างเวอร์ชันใดๆ ตั้งแต่นั้นมา และตอนนี้รู้สึกมั่นใจที่จะสัญญาความเข้ากันได้ย้อนหลังทั่วไปสำหรับรูปแบบไฟล์ เราจะยังคงพัฒนารูปแบบต่อไปเพื่อผลักดันความสามารถและประสิทธิภาพ แต่ข้อมูลเก่าจะโหลดได้เสมอ

ก่อน 0.32 คุณสามารถเขียนไฟล์ .rrd ได้โดยใช้ importer จากรูปแบบอื่นหรือ API ระดับสูง \log\ หรือ \send_columns\ เท่านั้น และวิธีเดียวในการอ่านข้อมูลคือผ่าน dataframe หรือ SQL queries ด้วยการเปิดตัวนี้ เรากำลังแนะนำ API การอ่านและเขียนระดับ chunk ซึ่งให้การควบคุมที่แม่นยำเหนือรูปร่างที่แน่นอนของข้อมูลของคุณ

เมื่อรวมกันแล้ว การเปลี่ยนแปลงทั้งสองนี้หมายความว่า .rrd มีความสมบูรณ์เพียงพอสำหรับทีมงานที่หลากหลายในการสร้างเลเยอร์ข้อมูลของพวกเขา

Chunk processing APIs สำหรับการจัดการข้อมูลที่เป็นมิตรกับหุ่นยนต์

ข้อมูลหุ่นยนต์มักจะยุ่งเหยิง การทำให้ข้อมูลจากหลายแหล่งเป็นมาตรฐานเป็นสิ่งที่ทีมงานสามารถวิเคราะห์และฝึกฝนได้นั้นซับซ้อนอย่างรวดเร็ว ส่วนนี้ของไปป์ไลน์ข้อมูลมักประกอบด้วยสคริปต์ Python ที่ประกอบกันอย่างไม่เป็นระเบียบ ซึ่งช้าและเต็มไปด้วยข้อบกพร s subtle

เพื่อแก้ปัญหาเหล่านี้ เรากำลังแนะนำชุด (ทดลอง) \chunk processing APIs\ ใหม่ พวกมันให้อินเทอร์เฟซตัวโหลดที่สม่ำเสมอสำหรับรูปแบบเช่น .rrd, MCAP, Parquet และ URDF ที่สร้างสตรีมของ Apache Arrow chunks จากนั้นคุณสามารถกำหนดไปป์ไลน์การประมวลผลบนสตรีมเหล่านั้นได้อย่างง่ายดาย

ข้อมูลหุ่นยนต์มักมาในรูปแบบของ structs ที่ซ้อนกันลึก และการทำให้ข้อมูลเป็นมาตรฐานและการจัดการมักหมายถึงการปรับรูปร่าง การแปลงชนิด และการแปลงเนื้อหา เพื่อตอบสนองความต้องการนั้น เรายังปล่อย Lenses ซึ่งเป็นภาษาที่ประกาศสำหรับการเลือกและแปลงข้อมูลประเภทนี้ โดยได้รับแรงบันดาลใจจาก jq

API เหล่านี้ได้รับการออกแบบอย่างชัดเจนสำหรับและทดสอบกับ coding agents และเราพบว่าพวกมันสร้างโค้ดที่ถูกต้องและมีประสิทธิภาพได้ง่ายกว่ามากด้วย Rerun chunk processing APIs มากกว่า Python ทั่วไป ในอนาคต การแปลง chunk processing เหล่านี้จะสามารถทำงานใน viewer และในคลาวด์ผ่าน Rerun Hub นอกเหนือจากตัวดำเนินการฝั่ง SDK ปัจจุบัน

การรองรับในตัวที่ขยายสำหรับ MCAP, ROS 2 types และการแสดงภาพหุ่นยนต์

เราคิดว่าสิ่งสำคัญคือการนำเข้าข้อมูลหุ่นยนต์ทั้งหมดและทำให้มีประโยชน์ใน Rerun ได้ง่าย ในเวลาเดียวกัน มีข้อมูลจำนวนมากที่สามารถจัดการได้อย่างสมบูรณ์แบบโดยไม่ต้องปรับแต่ง และเรายังคงปรับปรุงประสบการณ์นั้นในทุกการเปิดตัว 0.32 นำประสิทธิภาพที่ดีขึ้นและการรองรับทันทีมากขึ้นสำหรับ MCAP และ ROS 2 types ทั่วไป รวมถึงการขยายการแสดงภาพที่มีอยู่ ดูรายการข้อความที่อัปเดตพร้อมการรองรับในตัวได้ที่นี่

Occupancy grids หรือแผนที่ 2D ใน 3D มีความสำคัญสำหรับหุ่นยนต์เคลื่อนที่ และเป็นฟีเจอร์ที่ได้รับการร้องขออย่างหนักใน Rerun มาระยะหนึ่งแล้ว ดังนั้น 0.32 จึงเพิ่ม GridMap archetype และ visualizer ใหม่ พร้อมกับการรองรับในตัวสำหรับข้อความ ROS 2 ที่เกี่ยวข้อง

คำขอทั่วไปอีกประการหนึ่งคือความสามารถในการแสดงภาพการเปลี่ยนแปลงสถานะเมื่อเวลาผ่านไป 0.32 นำ State Timeline View ทดลองใหม่ หากคุณรอมุมมองนี้ใน Rerun เรายินดีรับฟังความคิดเห็นของคุณเกี่ยวกับสิ่งที่คุณต้องการเห็นเพิ่มเติมจากมุมมองนี้

เซิร์ฟเวอร์แคตตาล็อกพร้อม SQL หรือ dataframe queries ที่จัดทำดัชนีเหนือเนื้อหาของการบันทึกหลายรายการบนดิสก์

Catalog APIs ใน Rerun SDK ช่วยให้คุณเขียน SQL หรือ Dataframe queries ทั่วไปบนชุดข้อมูลหุ่นยนต์ เมื่อเชื่อมต่อกับ Rerun Hub สิ่งนี้รองรับชุดข้อมูลขนาดใหญ่มาระยะหนึ่งแล้ว ในขณะที่เซิร์ฟเวอร์โอเพนซอร์สรองรับเฉพาะชุดข้อมูลที่พอดีกับหน่วยความจำทั้งหมด ด้วย 0.32 เรากำลังขยายเซิร์ฟเวอร์แคตตาล็อกโอเพนซอร์สให้จัดทำดัชนีช่วงไบต์ของไฟล์บนดิสก์ท้องถิ่น เพื่อให้คุณสามารถวิเคราะห์ไดเรกทอรีท้องถิ่นใดๆ ของการบันทึกหุ่นยนต์ในไฟล์ .rrd ได้อย่างง่ายดายด้วย SDK โอเพนซอร์สเท่านั้น

UI ใหม่สำหรับการตรวจสอบชุดข้อมูลอย่างรวดเร็วสำหรับการฝึกฝนและการประเมินผล

ใน 0.32 เรากำลังจัดส่งเวอร์ชันแรกของเครื่องมือตรวจสอบชุดข้อมูล (ทดลอง) ของเรา ช่วยให้คุณสามารถดูภาพรวมของการบันทึกหลายรายการพร้อมกัน เพื่อล่าหาความผิดปกติและสร้างสัญชาตญาณสำหรับข้อมูลของคุณ นอกจากนี้ยังช่วยให้คุณทำเครื่องหมายการบันทึก ทำให้มีประโยชน์เป็นเครื่องมือ annotate อย่างง่าย มุมมองถูกกำหนดค่าโดยใช้ blueprint Rerun ปกติ

ทีมการเรียนรู้ของหุ่นยนต์หลายทีมขอฟังก์ชันนี้ และเรายินดีรับฟังความคิดเห็นทั้งหมดของคุณเกี่ยวกับวิธีเปลี่ยนสิ่งนี้ให้เป็นเครื่องมือตรวจสอบชุดข้อมูลที่มีประสิทธิภาพสูงสุดเท่าที่จะเป็นไปได้

ตัวโหลดข้อมูลสำหรับการเรียนรู้ของหุ่นยนต์ที่รองรับการผสมชุดข้อมูลอย่างง่ายและการค้นหาแบบสุ่มในไฟล์ .rrd

เราเริ่มทำงานกับหนึ่งในฟีเจอร์ที่ได้รับการร้องขอมากที่สุด: ตัวโหลดข้อมูล PyTorch สำหรับ Rerun! โมดูล rerun.experimental.dataloader ใหม่เปิดเผยการบันทึก Rerun เป็นชุดข้อมูล PyTorch แบบ iterable หรือ map-style โดยสตรีมภาพที่เข้ารหัส สเกลาร์ และวิดีโอที่บีบอัด (h264/h265/av1) แบบทันที การเข้าถึงแบบสุ่ม การดึงข้อมูลล่วงหน้าแบบหลาย worker และการรองรับ DDP ทำงานทันที เข้ากันได้กับทั้งเซิร์ฟเวอร์แคตตาล็อก OSS และผลิตภัณฑ์เชิงพาณิชย์ของเรา Rerun Hub สำหรับเมื่อคุณต้องการฝึกฝนโดยตรงบนชุดข้อมูลขนาดใหญ่ที่ backed โดย object storage

เราตื่นเต้นอย่างเหลือเชื่อที่จะปล่อยตัวโหลดข้อมูลการฝึกฝนนี้ให้ชุมชนได้เริ่มทดลอง เราตั้งใจที่จะทำให้สิ่งนี้เป็นตัวโหลดข้อมูลสตรีมมิ่งที่ดีที่สุดสำหรับการเรียนรู้ของหุ่นยนต์เท่าที่จะจินตนาการได้ และยินดีรับฟังความคิดเห็นและคำขอทั้งหมดของคุณ

ความสามารถในการฝึกฝนโดยตรงจากเลเยอร์ข้อมูลเดียวกับที่คุณใช้สำหรับการแสดงภาพ การวิเคราะห์ และการแปลง เป็นสิ่งสำคัญสำหรับทีมงานในการรวมเลเยอร์ข้อมูลของพวกเขาอย่างแท้จริง ซึ่งเป็นวิธีที่พวกเขาสามารถทำให้ระบบง่ายขึ้นและเร่งวงจรการทดลองได้อย่างแท้จริง

Rerun Hub อยู่ในพรีวิวส่วนตัวและสร้างขึ้นเพื่อการปรับขนาด

ในช่วงปีครึ่งที่ผ่านมา เราได้สร้างเลเยอร์ข้อมูลที่จำเป็นเพื่อเร่งการนำการเรียนรู้ของหุ่นยนต์ไปสู่การใช้งานจริงที่มีคุณค่าร่วมกับสตาร์ทอัพและแล็บที่ยอดเยี่ยมกลุ่มแรกๆ ปัจจุบันเราจัดการข้อมูลการฝึกฝนหุ่นยนต์ระดับเพตาไบต์ และอยู่ในจุดที่เราพร้อมที่จะรับทีมงานเพิ่มเติมเข้าสู่ผลิตภัณฑ์เชิงพาณิชย์ของเรา Rerun Hub ซึ่งตอนนี้กำลังเข้าสู่พรีวิวส่วนตัว

Rerun Hub เป็นแคตตาล็อกและเอนจินจัดเก็บที่เชื่อมต่อกับ Rerun SDK โอเพนซอร์สเพื่อให้ทำงานกับข้อมูลการเรียนรู้ของหุ่นยนต์ตั้งแต่การรวบรวมจนถึงการฝึกฝนและการปรับใช้ได้ง่าย โดยทำหน้าที่เป็นเลเยอร์การจัดการและการเข้าถึงที่สม่ำเสมอซึ่งขับเคลื่อนความสามารถหลักของข้อมูลทั้งหมด ตั้งแต่การนำเข้า การแสดงภาพ การค้นหาเชิงวิเคราะห์ การแปลง และการฝึกฝน ข้อมูลสามารถจัดเก็บใน object storage ที่เข้ากันได้กับ S3 ใดๆ และ Rerun Hub จะเป็นสื่อกลางในการสตรีมแบบเลือกโดยตรงจาก object storage ไปยัง Rerun SDK ในงานฝึกฝนหรือประมวลผลภายหลังแบบขนานขนาดใหญ่ของคุณ ฮับแบบรวมศูนย์ยังช่วยให้การทำงานร่วมกันและการตรวจสอบอัตโนมัติง่ายขึ้น โดยทำให้ง่ายต่อการสร้างลิงก์ข้อมูลที่แชร์ได้ ไม่ว่าจะผ่านโค้ดหรือแบบโต้ตอบใน viewer

หากคุณกำลังสร้างหุ่นยนต์อัจฉริยะและสนใจที่จะอัปเกรดเลเยอร์ข้อมูลของคุณเพื่อให้คุณสามารถวนซ้ำได้เร็วขึ้น ติดต่อเรา สำหรับทีมงานที่ถึงขนาดหนึ่งแล้วกับระบบที่มีอยู่ที่ซับซ้อน Rerun นั้นง่ายต่อการนำไปใช้แบบเป็นชิ้นส่วน และเรายังสามารถเสนอวิศวกรที่ประจำการเพื่อช่วยคุณอัปเกรดโดยไม่ต้องย้ายคนหลักออกจากลำดับความสำคัญอื่นๆ