# Scalable Environment Setup and Policy Evaluation in Simulation with Isaac Lab-Arena and GR00T

## Abstract

In this hands-on lab, you’ll gain expertise on workflows for simulation-based policy evaluation, including how to setup simulation environments with Isaac Lab Arena, how to post-train GR00T models for custom tasks and how to evaluate trained policies in simulation at scale. NVIDIA Isaac Lab Arena is a framework for scalable policy evaluation in simulation. NVIDIA Isaac GR00T provides robot foundation models for cognition and control, built on NVIDIA Omniverse™ and Cosmos™. Prerequisite(s): Intermediate experience with Python, including working with packages, virtual environments, and basic scripting. Understand command-line usage for running scripts and managing project files. Have familiarity with robotics or simulation workflows (for example, using simulation tools or working with physics-enabled assets). Explore training opportunities from the NVIDIA Deep Learning Institute  (DLI). Access a wide range of self-paced courses  or instructor-led virtual workshops  designed to build key skills in AI, HPC, graphics & simulation, and more.   Validate your skills with NVIDIA certification  and distinguish yourself in the industry.

## AI Summary

- The presentation covered the introduction and features of Isaac Lab Arena, an open-source framework for scalable task curation and policy evaluation in simulation.
- The framework simplified task curation by allowing users to compose tasks from modular components, such as environments, scenes, objects, robots, and skills.
- Isaac Lab Arena introduced the concept of affordances, enabling objects to interact with the environment in specific ways, and relational object placement, which simplified the setup of object positions.
- The presentation demonstrated how to set up a sequential pick and place task and a closed door task using a humanoid robot, and how to scale these tasks to multiple parallel environments.
- The team provided hands-on examples of training policies using imitation learning and reinforcement learning, and evaluating these policies across different scenarios.
- The presentation concluded with a call to action for users to provide feedback, try out the 0.2 version of Isaac Lab Arena, and share their tasks and benchmarks with the community.

## Transcript

**[00:00:10 – 00:00:13]** Okay, good morning everyone, and so nice to see everyone

**[00:00:13 – 00:00:14]** here, we're really excited.

**[00:00:14 – 00:00:17]** There's a couple of just initial setup things that we wanted

**[00:00:17 – 00:00:19]** to get started on.

**[00:00:19 – 00:00:21]** So if you haven't had a chance already, could you go ahead

**[00:00:21 – 00:00:26]** and please connect to our Wi-Fi and go over to the learn.nvidia.com

**[00:00:26 – 00:00:28]** slash DLI event URL.

**[00:00:28 – 00:00:31]** There we'll be running some hands-on exercises today, and

**[00:00:31 – 00:00:34]** it takes a couple of minutes to get started, to launch that instance.

**[00:00:34 – 00:00:37]** And so I just wanted to make sure everyone gets that started

**[00:00:37 – 00:00:39]** before we actually start with our presentation part.

**[00:00:39 – 00:00:42]** So, can everyone just maybe raise your hands if you're

**[00:00:42 – 00:00:45]** at that URL, and you've been able to enter the event code?

**[00:00:45 – 00:00:49]** Okay, so if everyone, I'm going to show you what's on

**[00:00:49 – 00:00:51]** my screen right now as I log in.

**[00:00:51 – 00:00:54]** Go ahead and click on the start button, and it should just

**[00:00:54 – 00:00:57]** show you the loading symbol, and that will take a couple of minutes.

**[00:00:57 – 00:01:00]** So, while that's cooking, Sangeeta is going to come

**[00:01:00 – 00:01:02]** and give us a quick introduction about Isaac Lab Arena.

**[00:01:02 – 00:01:07]** Quick show of hands, is everyone here at the loading page right now?

**[00:01:07 – 00:01:10]** Excellent. And if not, feel free to ask for any of our tiers for

**[00:01:10 – 00:01:13]** help, and they'll get you there.

**[00:01:13 – 00:01:18]** So, let's have Sangeeta start with Isaac Lab Arena.

**[00:01:21 – 00:01:23]** Thank you, Asa.

**[00:01:23 – 00:01:24]** Morning, morning, everyone.

**[00:01:24 – 00:01:28]** Thank you for making it early this morning.

**[00:01:28 – 00:01:30]** I hope you're having a good GTC.

**[00:01:31 – 00:01:35]** And what we'll do today is I'll spend the next couple

**[00:01:35 – 00:01:38]** of minutes giving you

**[00:01:38 – 00:01:41]** An overview of what is Isaac Lab Arena, what we're trying to solve

**[00:01:41 – 00:01:47]** for here, and how it can hopefully help make your policy benchmarking

**[00:01:47 – 00:01:53]** in simulation easier and faster.

**[00:01:55 – 00:01:58]** It's an interesting time for robotics.

**[00:01:58 – 00:02:04]** The past year alone has seen an explosion in generalist policies

**[00:02:04 – 00:02:11]** and foundation models that are meant to do a wide range of tasks.

**[00:02:11 – 00:02:15]** Almost like here you see the group model doing a bunch of things

**[00:02:15 – 00:02:21]** in your home, loading dishwashers in a factory assembly line.

**[00:02:23 – 00:02:30]** warehouse I guess and trying to be cute maybe but yeah the the

**[00:02:30 – 00:02:36]** challenge upon us while trying to build these generalist policies is

**[00:02:37 – 00:02:43]** from trying to train and evaluate them for one task it just blew up

**[00:02:43 – 00:02:49]** to the need to be able to train and evaluate them against this diverse

**[00:02:49 – 00:02:51]** set of thousands of skills times

**[00:02:51 – 00:02:55]** That many permutations of environments, scenarios, robots

**[00:02:55 – 00:02:59]** and parameters within to be able to then analyze the policy

**[00:02:59 – 00:03:02]** performance and get meaningful

**[00:03:02 – 00:03:05]** Results at a reasonably fast pace so that you can come

**[00:03:05 – 00:03:09]** back and improve the policy, right?

**[00:03:09 – 00:03:14]** But there's gaps before we get there.

**[00:03:14 – 00:03:18]** Show of hands, how many of us are familiar with setting up tasks

**[00:03:18 – 00:03:23]** on Isaac Lab or simulation even?

**[00:03:23 – 00:03:30]** Okay, then you know that curating a task on Isaac Lab, or any

**[00:03:30 – 00:03:33]** simulator for that matter, is still, there's work, you

**[00:03:33 – 00:03:36]** have to configure the scene, the events, the rewards, it's

**[00:03:37 – 00:03:39]** tedious and manual, and then when you try and expand this

**[00:03:39 – 00:03:43]** to more task libraries with more...

**[00:03:43 – 00:03:46]** Um, say, uh, diversity, it just gets exponentially, the

**[00:03:46 – 00:03:49]** effort and redundancy gets exponentially worse.

**[00:03:49 – 00:03:52]** And so naturally, each one of us is building our own

**[00:03:52 – 00:03:56]** custom scaffolds to stand up our task libraries and benchmarks.

**[00:03:56 – 00:04:00]** Um, this is both fragmented and high overhead, and we're

**[00:04:00 – 00:04:04]** still not hitting the kind of, uh, complexity, diversity,

**[00:04:04 – 00:04:08]** and experimentation that we want to do, uh, to truly exploit

**[00:04:08 – 00:04:10]** the potential of sim.

**[00:04:10 – 00:04:15]** And even if we manage to set up all those tasks, benchmarking

**[00:04:15 – 00:04:17]** takes a lot of time and compute.

**[00:04:17 – 00:04:19]** If we end up doing this sequentially, it's going

**[00:04:19 – 00:04:22]** to take us hours and days, and we end up then compromising

**[00:04:22 – 00:04:27]** on the depth of analytics that we would have ideally liked.

**[00:04:27 – 00:04:30]** So to address some of these problems is why we're investing

**[00:04:30 – 00:04:33]** in Isaac Lab Arena.

**[00:04:33 – 00:04:35]** It's a framework.

**[00:04:35 – 00:04:40]** An open-source framework that extends base Isaac Lab to

**[00:04:40 – 00:04:46]** offer two key things, just scalable task curation and large-scale

**[00:04:46 – 00:04:48]** policy evaluation in SIEM.

**[00:04:48 – 00:04:53]** Now, this comes down to a few key features, and we'll spend the rest

**[00:04:53 – 00:04:56]** of the session diving into that and getting you down and dirty with

**[00:04:56 – 00:05:00]** it, so you'll see this in depth.

**[00:05:00 – 00:05:04]** But at a high level, this comes down to three simple things.

**[00:05:04 – 00:05:05]** One is

**[00:05:05 – 00:05:10]** Simplifying task curation, allowing you to set up your

**[00:05:10 – 00:05:12]** tasks easily and in a scalable way.

**[00:05:12 – 00:05:16]** So how Arena does this is it moves away from these monolithic

**[00:05:16 – 00:05:22]** task scripts and lets you compose your tasks from independent

**[00:05:22 – 00:05:27]** or modular LEGO blocks, Like your environment, plus

**[00:05:27 – 00:05:32]** Your scene plus object plus robot plus skills, like say you

**[00:05:32 – 00:05:37]** can say pick plus walk plus place, and Arena will assemble that into

**[00:05:37 – 00:05:41]** an Isaac Lab Manager environment on the fly for you dynamically.

**[00:05:41 – 00:05:45]** So just dynamic environment composition, which makes it

**[00:05:46 – 00:05:50]** easy for you to go from an idea of your task in your head to an

**[00:05:50 – 00:05:55]** Isaac Lab simulation in a scalable way such that you can swap.

**[00:05:55 – 00:05:59]** Mix and match parts so that you can build that diversity

**[00:05:59 – 00:06:04]** of n variations possible within that universe.

**[00:06:04 – 00:06:08]** And ultimately what you build is an Isaac Lab Environment so you can

**[00:06:08 – 00:06:11]** not just use your benchmark that you just built, you can not just

**[00:06:11 – 00:06:16]** use it for evaluation directly, you can also interoperate it with

**[00:06:16 – 00:06:20]** Anything that you could do on-base Isaac Lab, which is

**[00:06:20 – 00:06:23]** learning, which is synthetic data generation for imitation

**[00:06:23 – 00:06:25]** learning, reinforcement learning.

**[00:06:25 – 00:06:27]** Basically train your policy till you're ready to come

**[00:06:27 – 00:06:29]** back and evaluate.

**[00:06:29 – 00:06:33]** You can use the environment seamlessly to do all of that.

**[00:06:33 – 00:06:38]** So that's mostly about simplifying task curation.

**[00:06:38 – 00:06:43]** Really, where all of this is headed is to be able to

**[00:06:43 – 00:06:46]** move towards a world where we can agentically, using

**[00:06:46 – 00:06:53]** natural language prompt, build our desired tasks and environments.

**[00:06:53 – 00:06:56]** And from what we see in the community in early research,

**[00:06:56 – 00:06:58]** this is not very far.

**[00:06:59 – 00:07:01]** So once you're able to set up your tasks easily,

**[00:07:01 – 00:07:04]** The other portion is because your tasks are atomic and

**[00:07:04 – 00:07:09]** LEGO-like, you can also define these metrics that are very scale

**[00:07:09 – 00:07:15]** and affordance specific, which lets you get this depth of granular

**[00:07:16 – 00:07:20]** analysis and incremental analysis to see how your policy performs.

**[00:07:20 – 00:07:24]** And where we're going with this is to be able to make

**[00:07:24 – 00:07:28]** this further easier, as in allow you to easily configure

**[00:07:28 – 00:07:31]** different variations across

**[00:07:31 – 00:07:35]** Visual, structural, physics, kinematic parameters allow

**[00:07:35 – 00:07:39]** you to configure isolated variations to each of this and then

**[00:07:39 – 00:07:42]** see how your policy, being able to sweep across all of them and

**[00:07:42 – 00:07:47]** seeing how your policy degrades or gets affected by these variations

**[00:07:47 – 00:07:50]** so that you get very targeted feedback, actionable feedback

**[00:07:50 – 00:07:54]** to go back and improve your policy.

**[00:07:54 – 00:07:58]** Now once you've covered that, you have breadth of diversity,

**[00:07:58 – 00:08:01]** you have depth of analysis, so coverage is not a problem.

**[00:08:01 – 00:08:04]** The next bottleneck you'll hit is time.

**[00:08:04 – 00:08:06]** If you try and run all of these sequentially, it's

**[00:08:06 – 00:08:08]** going to take you...

**[00:08:09 – 00:08:14]** That's when we, Isaac Lab Arena's parallel evaluation

**[00:08:14 – 00:08:15]** comes into picture.

**[00:08:15 – 00:08:20]** You can evaluate your policy against multiple parallel

**[00:08:20 – 00:08:23]** environments simultaneously.

**[00:08:23 – 00:08:25]** They can be homogenous environments where they're

**[00:08:25 – 00:08:27]** just parameter changes.

**[00:08:27 – 00:08:31]** Or we recently introduced heterogeneous object level

**[00:08:31 – 00:08:34]** heterogeneity environments where you can have different

**[00:08:34 – 00:08:38]** objects, manipulation objects in each of these parallel environments

**[00:08:38 – 00:08:43]** and roll out your policy in parallel and get analysis.

**[00:08:43 – 00:08:46]** So together with this, hopefully it will help you set up your

**[00:08:46 – 00:08:51]** task with ease, get that breadth of coverage, depth of analysis,

**[00:08:51 – 00:08:56]** but with parallelism, hopefully in unprecedented speed.

**[00:08:56 – 00:09:03]** So that's that's the intent of what the framework hopes to offer.

**[00:09:04 – 00:09:08]** With ARENA, you not just get a framework, you also, so

**[00:09:08 – 00:09:12]** not just you have the framework to build your tasks like LEGO,

**[00:09:12 – 00:09:15]** NVIDIA and our partners are also building their industrial

**[00:09:15 – 00:09:18]** and academic benchmarks on ARENA.

**[00:09:18 – 00:09:23]** So you get access to community LEGO as well where you can use their

**[00:09:23 – 00:09:28]** Metrics, tasks, data sets, scenes, and adapt them for your

**[00:09:28 – 00:09:30]** custom evaluations as you deem fit.

**[00:09:30 – 00:09:33]** I'm not going to go over all of them, we'll post links

**[00:09:33 – 00:09:38]** to what's available as well, but essentially, we at NVIDIA

**[00:09:38 – 00:09:41]** are building the GROOT model, GROOT's industrial benchmarks are

**[00:09:41 – 00:09:43]** also based on building on ARENA.

**[00:09:43 – 00:09:47]** Lightwheel has done a bunch of work to do their RoboFinals

**[00:09:47 – 00:09:48]** Industrial Benchmark on Arena.

**[00:09:48 – 00:09:51]** We have NIST, Dex Bench coming soon.

**[00:09:51 – 00:09:55]** On the academic side, Lightwheel has done a ton of work to

**[00:09:55 – 00:10:01]** adapt the Robocasa and LIBERO benchmarks to Isaac Lab.

**[00:10:01 – 00:10:05]** They have a high fidelity, about 250 plus tasks with like seven

**[00:10:05 – 00:10:08]** plus robots and 50 data sets each.

**[00:10:08 – 00:10:11]** And these are all open source.

**[00:10:11 – 00:10:13]** Someone's controlling it.

**[00:10:13 – 00:10:14]** Thank you.

**[00:10:14 – 00:10:16]** And these are all open source.

**[00:10:16 – 00:10:20]** RoboTwin recently moved some of their benchmarks

**[00:10:20 – 00:10:22]** over and are building their next generation on Arena.

**[00:10:22 – 00:10:27]** So you get this gamut of community-built benchmarks

**[00:10:27 – 00:10:31]** on this common core so that you will hopefully all be able to

**[00:10:31 – 00:10:35]** share and benefit from each other's

**[00:10:35 – 00:10:37]** LEGOs and push boundaries on this.

**[00:10:37 – 00:10:42]** And this is across manipulation, locomotion, and locomanipulation.

**[00:10:42 – 00:10:45]** Deployment-wise, fairly straightforward.

**[00:10:45 – 00:10:48]** You can deploy it on a local PC, you can put it on a cloud-native

**[00:10:48 – 00:10:51]** orchestration platform like OSMO.

**[00:10:51 – 00:10:54]** We went and integrated it into Lerobot Environment Hub as well,

**[00:10:54 – 00:10:58]** so if you're a fan of the Lerobot ecosystem, you can integrate

**[00:10:58 – 00:11:03]** your arena benchmarks there and then do training and evaluation

**[00:11:03 – 00:11:05]** in the Lerobot framework.

**[00:11:05 – 00:11:08]** But this pretty much scales to any cloud-native leaderboard

**[00:11:08 – 00:11:11]** or dashboard for that matter.

**[00:11:11 – 00:11:15]** So that was the high level of what ARENA is trying to solve for.

**[00:11:15 – 00:11:19]** It's a framework that extends Isaac Lab for task curation

**[00:11:19 – 00:11:21]** and policy evaluation at scale.

**[00:11:22 – 00:11:23]** The key...

**[00:11:23 – 00:11:26]** Key things that it's trying to offer are simplifying your task

**[00:11:26 – 00:11:31]** curation 0 to 1, or simplifying your scaling 1 to n, and then

**[00:11:31 – 00:11:34]** giving you the hooks to be able to do this kind of systematic,

**[00:11:34 – 00:11:38]** granular diagnostics for meaningful feedback, and then being able

**[00:11:38 – 00:11:41]** to do that at scale and having access to all of these.

**[00:11:41 – 00:11:44]** The team will spend the rest of the session diving into each of these

**[00:11:44 – 00:11:47]** pieces, giving you a technical overview of the concepts and

**[00:11:47 – 00:11:52]** how the code is set up, and also

**[00:11:59 – 00:12:03]** Exemplifying them hands-on so that hopefully you all will walk home

**[00:12:03 – 00:12:08]** from here being able to go dive in and play with this a lot more.

**[00:12:08 – 00:12:11]** Quick context on project status.

**[00:12:11 – 00:12:14]** If you saw my updates earlier, you would have seen summer coming soon.

**[00:12:14 – 00:12:16]** That's because we are in alpha right now.

**[00:12:16 – 00:12:20]** Isaac Lab Arena is an open source project.

**[00:12:20 – 00:12:23]** The intent of building it in the open is so that we

**[00:12:23 – 00:12:26]** can build a shared common core.

**[00:12:26 – 00:12:28]** That we can all invest in and extend together, which

**[00:12:29 – 00:12:33]** is why we're open sourcing it in the nascent stages.

**[00:12:33 – 00:12:38]** Alpha is available today on main and I'll come back later after

**[00:12:39 – 00:12:42]** the team goes through it and talk about what we're thinking of in

**[00:12:42 – 00:12:48]** our next versions and how you can help collaborate, shape it with us.

**[00:12:48 – 00:12:51]** We super appreciate it at this point given we're in

**[00:12:51 – 00:12:54]** alpha and trying to build towards this common future.

**[00:12:54 – 00:12:59]** All right, that's all I had, and I'll hand it over to Alex,

**[00:12:59 – 00:13:04]** who's going to give you a technical overview of how everything that I

**[00:13:04 – 00:13:09]** said is possible was made possible.

**[00:13:14 – 00:13:17]** Hey, everyone, I'm Alex, and I'm going to give you a bit

**[00:13:17 – 00:13:21]** of a technical overview of what we have in Isaac Lab Arena.

**[00:13:21 – 00:13:24]** This is going to be a bit of a lightning fast introduction,

**[00:13:24 – 00:13:29]** but me and the team are happy to talk about this in more detail.

**[00:13:29 – 00:13:31]** So come find us after.

**[00:13:31 – 00:13:36]** So as Sangeeta touched upon, the advances in robot learning

**[00:13:36 – 00:13:40]** over the last year have led to robot foundation models which

**[00:13:40 – 00:13:42]** are defined by their generality.

**[00:13:42 – 00:13:46]** So this is an example of Pi 0.5, which is given a high-level

**[00:13:46 – 00:13:51]** instruction to clean this Airbnb in San Francisco, which

**[00:13:51 – 00:13:57]** it breaks down into a series of subtasks, which it then completes.

**[00:13:57 – 00:14:02]** Now, we'd like to evaluate these models, and doing so

**[00:14:02 – 00:14:07]** requires a diverse set of simulation environments.

**[00:14:07 – 00:14:10]** So let's start with the motivating example.

**[00:14:10 – 00:14:15]** This is like a small task library for evaluating a robot

**[00:14:15 – 00:14:20]** for this task of transferring an object from a counter to a ball.

**[00:14:20 – 00:14:23]** And because we wanna test the policy's generality,

**[00:14:23 – 00:14:27]** We introduce variation upon two axes here.

**[00:14:27 – 00:14:31]** So on the x-axis, you have us varying the object to

**[00:14:31 – 00:14:34]** be transferred over various fruit and vegetables.

**[00:14:34 – 00:14:39]** And on the y-axis, we have variations in the robot embodiment.

**[00:14:39 – 00:14:43]** So one critical thing when you're putting something like

**[00:14:43 – 00:14:46]** this together is how do you represent these environments

**[00:14:46 – 00:14:47]** in your code base?

**[00:14:47 – 00:14:51]** And so on the right here, you have a snippet of Isaac

**[00:14:51 – 00:14:55]** Lab code for representing this environment, but let's

**[00:14:55 – 00:14:58]** abstract that and say it's some piece of code that represents the

**[00:14:58 – 00:15:03]** scene, objects within the scene, the task, what the robot should

**[00:15:03 – 00:15:07]** do, and the robot embodiment.

**[00:15:07 – 00:15:11]** Now, as we start to introduce variation in these environments,

**[00:15:12 – 00:15:15]** so here we've switched the apple for a banana, you know,

**[00:15:15 – 00:15:18]** you have to generate a new one of these descriptions and

**[00:15:18 – 00:15:20]** maintain that in your code base.

**[00:15:20 – 00:15:26]** And so, you know, as you introduce more variation, this problem

**[00:15:26 – 00:15:30]** worsens, you know, you're maintaining many of these

**[00:15:30 – 00:15:34]** environment descriptions, even for this toy example.

**[00:15:34 – 00:15:39]** And so Isaac Lab Arena is sort of aimed at solving that problem.

**[00:15:40 – 00:15:44]** So it's an open source framework for scalable task curation and

**[00:15:44 – 00:15:47]** policy evaluation and simulation.

**[00:15:47 – 00:15:51]** So I want to talk about some of the features that make all

**[00:15:51 – 00:15:57]** this, or make task curation easy.

**[00:15:58 – 00:16:02]** So if we return to our motivating example where we're maintaining

**[00:16:02 – 00:16:06]** these environment descriptions, ARENA takes a different approach,

**[00:16:06 – 00:16:10]** we sort of maintain a library of environment parts, which

**[00:16:10 – 00:16:14]** is what you see on the right hand side of the slide here,

**[00:16:14 – 00:16:17]** so to put together an environment

**[00:16:17 – 00:16:24]** You know, a user can select some of these parts, and at

**[00:16:24 – 00:16:30]** runtime, the arena compiler puts together an Isaac Lab environment

**[00:16:30 – 00:16:33]** for running your evaluation.

**[00:16:33 – 00:16:39]** So, yeah, this frees us from maintaining this sort of growing

**[00:16:39 – 00:16:43]** number of environment descriptions, and instead we maintain this

**[00:16:43 – 00:16:47]** library of environment parts.

**[00:16:47 – 00:16:53]** So Isaac Lab Arena introduces the concept of tasks.

**[00:16:53 – 00:16:56]** So a task describes what a robot should do in a

**[00:16:56 – 00:17:00]** simulation to successfully complete the evaluation.

**[00:17:01 – 00:17:04]** So in this case, we have this robot completing the task

**[00:17:04 – 00:17:08]** of opening the microwave door, and a task describes what

**[00:17:08 – 00:17:12]** does success look like, what does failure look like, and

**[00:17:12 – 00:17:17]** what are some metrics that measure how well the robot is doing.

**[00:17:17 – 00:17:21]** So ARENA has a library of these things like open and close

**[00:17:21 – 00:17:25]** door, pick up object, et cetera.

**[00:17:26 – 00:17:31]** So objects in Arena have something called affordances.

**[00:17:31 – 00:17:32]** So what is an affordance?

**[00:17:32 – 00:17:37]** An affordance is an interaction which is afforded to an

**[00:17:37 – 00:17:38]** agent in the scene.

**[00:17:38 – 00:17:42]** So for example here, the drill and the coffee machine have

**[00:17:42 – 00:17:46]** the affordance pressable because an agent can press a button on them.

**[00:17:46 – 00:17:53]** The microwave and the box are both openable for obvious reasons.

**[00:17:53 – 00:18:00]** And the idea here is that objects in ARENA are interactable,

**[00:18:00 – 00:18:05]** and this combines well with our concept of tasks, so a

**[00:18:05 – 00:18:10]** task is defined in terms of

**[00:18:10 – 00:18:15]** Objects with affordances, so for example, in this open, this

**[00:18:15 – 00:18:18]** task where the robot is opening the microwave door, you could switch

**[00:18:18 – 00:18:24]** the microwave for any openable object and get a valid environment

**[00:18:24 – 00:18:30]** for evaluation, so you could have an open-the-box environment.

**[00:18:31 – 00:18:34]** So as we started with, on the first slide of my part

**[00:18:34 – 00:18:39]** of the presentation where you had this Pi Zero breaking

**[00:18:39 – 00:18:44]** down sort of a larger task into a series of subtasks, you also want

**[00:18:44 – 00:18:49]** to be able to describe that kind of thing in the evaluation framework.

**[00:18:49 – 00:18:54]** So here you can see a robot who is tasked to sort of pick

**[00:18:54 – 00:18:58]** up a vegetable from the counter, transfer it to the fridge.

**[00:18:58 – 00:19:00]** And close the door.

**[00:19:00 – 00:19:06]** So in Arena, we represent this as the composition of two tasks.

**[00:19:06 – 00:19:10]** The pick and place task and a closed door task.

**[00:19:10 – 00:19:14]** And then you can sort of combine these into one composite task.

**[00:19:14 – 00:19:18]** And this means that putting these things together is

**[00:19:18 – 00:19:21]** pretty, is quite easy.

**[00:19:24 – 00:19:29]** So if any of you have tried to put together an environment

**[00:19:29 – 00:19:32]** programmatically, you probably know that one of the most

**[00:19:32 – 00:19:35]** annoying things to do is to position objects in the scene.

**[00:19:35 – 00:19:38]** This is typically done through explicit coding

**[00:19:38 – 00:19:40]** of their 3D positions.

**[00:19:40 – 00:19:44]** So in ARENA we have this thing called relational object placement

**[00:19:44 – 00:19:48]** where you can describe how the spatial arrangement of

**[00:19:48 – 00:19:53]** objects in terms of semantic concepts like the microwave

**[00:19:53 – 00:19:58]** is on the table and the cup is on the microwave and behind the scenes

**[00:19:58 – 00:20:04]** the ARENA compiler goes away and solves for some valid placement of

**[00:20:05 – 00:20:07]** objects that fits your description.

**[00:20:07 – 00:20:10]** So that's what you can see on the bottom right.

**[00:20:10 – 00:20:14]** And on the top right is a scene that's been sort of put together

**[00:20:15 – 00:20:18]** programmatically without any

**[00:20:18 – 00:20:22]** explicit coding of 3D positions.

**[00:20:23 – 00:20:29]** So we also have tools for putting together evaluation sets.

**[00:20:29 – 00:20:36]** So on the right here, you can see the GROOT N1.6 model tasked with

**[00:20:36 – 00:20:39]** transferring an object to a ball.

**[00:20:39 – 00:20:42]** And you can see that the scene is varied over placement of

**[00:20:42 – 00:20:47]** the objects, the background, and the lighting.

**[00:20:47 – 00:20:52]** And this is described by this JSON file Over on the

**[00:20:52 – 00:20:55]** right of the screen.

**[00:20:55 – 00:21:00]** Okay, so what can you do with all this?

**[00:21:01 – 00:21:07]** So I've touched briefly already on evaluation, but we also have

**[00:21:07 – 00:21:14]** workflows for imitation learning and reinforcement learning.

**[00:21:16 – 00:21:22]** Here you see an operator controlling the G1 robot in

**[00:21:22 – 00:21:26]** an environment in a simulation to complete this task of transferring

**[00:21:26 – 00:21:33]** the box to the table and then you can train a model, so this is GROOT

**[00:21:33 – 00:21:38]** and 1.6 trained to complete the same task and so if you go to our

**[00:21:38 – 00:21:42]** docs you can do all this yourself.

**[00:21:43 – 00:21:45]** All right, so that was a bit of a lightning run through

**[00:21:45 – 00:21:50]** our features, but just in summary, Isaac Lab Arena is this open

**[00:21:50 – 00:21:54]** source framework for scalable task curation and policy evaluation.

**[00:21:54 – 00:21:58]** I've been over some of the features, of course,

**[00:21:58 – 00:21:59]** there are many more.

**[00:21:59 – 00:22:03]** We have workflows for evaluation, imitation learning, and

**[00:22:03 – 00:22:04]** reinforcement learning.

**[00:22:04 – 00:22:06]** Yeah, try it out.

**[00:22:06 – 00:22:10]** I guess you're about to. And this is an early stage project,

**[00:22:10 – 00:22:16]** so we're looking for feedback on how to guide the development.

**[00:22:17 – 00:22:20]** I'll pass it over to Edith.

**[00:22:22 – 00:22:25]** Scalable Task Curation.

**[00:22:32 – 00:22:35]** So you're probably at any time.

**[00:22:38 – 00:22:42]** So we can actually tell people to launch it now, and I think

**[00:22:42 – 00:22:44]** most people haven't done it.

**[00:22:44 – 00:22:47]** Switch back.

**[00:22:56 – 00:22:58]** Awesome. Thanks, Alex.

**[00:22:58 – 00:22:59]** Thanks, Ngeeta. Hi, everyone.

**[00:22:59 – 00:23:04]** My name is Edith, and I, along with Asa, will carry on the

**[00:23:04 – 00:23:07]** rest of this course.

**[00:23:07 – 00:23:10]** So earlier on, Asa kind of showed you guys how to

**[00:23:10 – 00:23:11]** kind of launch this.

**[00:23:11 – 00:23:13]** You should see this on your screen.

**[00:23:13 – 00:23:17]** Hopefully, you are seeing this launch button.

**[00:23:17 – 00:23:19]** Go ahead and click that.

**[00:23:19 – 00:23:23]** That will take you to this kind of Jupyter notebook that we have here.

**[00:23:23 – 00:23:27]** Run this cell by pressing shift enter.

**[00:23:27 – 00:23:30]** It's going to open up a remote desktop.

**[00:23:30 – 00:23:33]** Go ahead and click that link.

**[00:23:33 – 00:23:36]** That link is going to take you to a virtual machine.

**[00:23:36 – 00:23:39]** It's going to take a second to run.

**[00:23:39 – 00:23:44]** If anybody has any questions, TAs are walking around in the corner.

**[00:23:44 – 00:23:45]** Well, we're going to get started here.

**[00:23:45 – 00:23:49]** This is where we're going to do all of our hands-on work.

**[00:23:49 – 00:23:53]** Isaac Labarena is set up here, all of the dependencies.

**[00:23:53 – 00:23:57]** So just a couple housekeeping items.

**[00:23:57 – 00:23:58]** These are lab instructions.

**[00:23:58 – 00:24:04]** So if you want to go ahead and click that, open that up, put it to

**[00:24:04 – 00:24:11]** the side, and then open up a We're Going to Be in Setup environment.

**[00:24:11 – 00:24:15]** If you look at that tab on your left there,

**[00:24:15 – 00:24:19]** I'll make it a little bit bigger so everyone can see.

**[00:24:20 – 00:24:27]** But we want to scroll down to kind of module two.

**[00:24:28 – 00:24:29]** Sorry.

**[00:24:29 – 00:24:32]** Scroll down to prerequisites.

**[00:24:32 – 00:24:34]** We're going to open up a console.

**[00:24:34 – 00:24:39]** So terminal, you can find that in the bottom corner here.

**[00:24:39 – 00:24:43]** And then you can go ahead and press console.

**[00:24:43 – 00:24:48]** In the terminal, we are going to type in code workspace.

**[00:24:48 – 00:24:53]** This is basically going to open up our VS code so that we can also

**[00:24:53 – 00:24:59]** have it side by side next to our instructions, giving it a second.

**[00:25:00 – 00:25:04]** Just go ahead here and click cancel if this is coming up for you as

**[00:25:04 – 00:25:06]** well, and then trust the authors.

**[00:25:06 – 00:25:08]** Yes, I trust.

**[00:25:08 – 00:25:09]** And then mark done.

**[00:25:09 – 00:25:16]** Hopefully people are on track again, TAs are floating around.

**[00:25:16 – 00:25:20]** From here, we are going to open up a terminal.

**[00:25:20 – 00:25:25]** So if you see the three kind of dots on the top there,

**[00:25:25 – 00:25:27]** you can click that.

**[00:25:27 – 00:25:30]** There should be a terminal icon.

**[00:25:34 – 00:25:36]** Sorry. I'm just eager.

**[00:25:36 – 00:25:38]** I know we started a little bit late.

**[00:25:39 – 00:25:41]** We started a little bit late, so I want to make sure you guys

**[00:25:41 – 00:25:45]** can get through the hand section.

**[00:25:45 – 00:25:46]** Yes, yes.

**[00:25:46 – 00:25:49]** Yeah, no worries. Again, TAs are walking around.

**[00:25:49 – 00:25:53]** The purpose, I just want to clarify, we're just going

**[00:25:53 – 00:25:55]** to have something set up running in the background.

**[00:25:55 – 00:25:59]** I will be giving a presentation after this, so again, TAs will

**[00:25:59 – 00:26:03]** be around helping you guys out.

**[00:26:05 – 00:26:08]** Yeah, so you should have gotten a code.

**[00:26:08 – 00:26:13]** It should be... Have you seen this page?

**[00:26:14 – 00:26:17]** So open remote work.

**[00:26:18 – 00:26:22]** OK, so we're back here in the console.

**[00:26:22 – 00:26:30]** So if you did cd slash workspace, you should, oh, sorry, not

**[00:26:30 – 00:26:36]** so, sorry, a code slash workspace, and that should open up VS

**[00:26:36 – 00:26:38]** Code in the background.

**[00:26:38 – 00:26:41]** There is no workspace?

**[00:26:45 – 00:26:50]** Forward slash workspace.

**[00:26:53 – 00:26:56]** Okay, okay.

**[00:26:57 – 00:26:59]** Got it.

**[00:26:59 – 00:27:04]** So you need to be in the virtual machine in order to run that.

**[00:27:04 – 00:27:07]** Just a quick highlight.

**[00:27:10 – 00:27:14]** Thank you.

**[00:27:17 – 00:27:19]** I'll give folks just a quick second here and then I'll

**[00:27:19 – 00:27:23]** get started with everything else.

**[00:27:40 – 00:27:45]** All right, I take it by the chatter.

**[00:27:45 – 00:27:48]** Hopefully, things are getting a little bit solved here,

**[00:27:48 – 00:27:49]** and we're on the same page.

**[00:27:49 – 00:27:53]** Just a quick show of hands, how many people see VS Code?

**[00:27:53 – 00:27:55]** Open up on the screen.

**[00:27:55 – 00:27:58]** Awesome, OK, cool, awesome, love that.

**[00:27:58 – 00:28:01]** OK, so let's continue.

**[00:28:01 – 00:28:05]** On the top corner, you can see my mouse hovering here.

**[00:28:05 – 00:28:07]** There are three dots.

**[00:28:07 – 00:28:09]** Go ahead and press that.

**[00:28:09 – 00:28:16]** Then go to Terminal, and then New Terminal.

**[00:28:16 – 00:28:19]** So go ahead and click that.

**[00:28:21 – 00:28:28]** Now, this opened up a terminal at the bottom corner of our VS code.

**[00:28:28 – 00:28:32]** If we go back to the instructions where we kind of had under

**[00:28:33 – 00:28:36]** the prerequisites tab, if you keep scrolling, we are

**[00:28:36 – 00:28:39]** going to copy these export.

**[00:28:39 – 00:28:43]** We just want to make sure that our file paths and everything are

**[00:28:43 – 00:28:45]** set for the rest of this course.

**[00:28:45 – 00:28:49]** So we're going to go ahead and copy that and then paste.

**[00:28:49 – 00:28:54]** So clicking enter.

**[00:28:54 – 00:28:58]** Then I'm going to run the next command here, copy

**[00:28:58 – 00:29:01]** that, and then paste.

**[00:29:02 – 00:29:05]** So just pasting those two things.

**[00:29:06 – 00:29:13]** So once I copied that second command, press Enter, I'm

**[00:29:13 – 00:29:16]** going to leave this running in the background.

**[00:29:29 – 00:29:33]** OK, we are going to leave this running in the background.

**[00:29:33 – 00:29:36]** But this is basically setting up.

**[00:29:36 – 00:29:38]** We have a couple of imports that are coming in.

**[00:29:38 – 00:29:39]** It's going to take some time.

**[00:29:39 – 00:29:42]** But as you can see, there's an Isaac Sim GUI already kind

**[00:29:42 – 00:29:45]** of coming up in the corner in the background there.

**[00:29:46 – 00:29:50]** So as long as folks are kind of in this area, again, TAs

**[00:29:50 – 00:29:53]** are floating around if you guys have any questions.

**[00:29:53 – 00:29:55]** But this is the state where I'm going to leave it right now.

**[00:29:55 – 00:29:58]** I'm going to be moving on to presentation.

**[00:29:58 – 00:30:03]** TAs can definitely help, and yeah, cool.

**[00:30:03 – 00:30:11]** So let me go ahead and play from current slide.

**[00:30:15 – 00:30:20]** Awesome, so Alex and Sangeeta went over an introduction

**[00:30:20 – 00:30:22]** of Isaac Lab Arena.

**[00:30:22 – 00:30:25]** They kind of talked about what were the two big things,

**[00:30:25 – 00:30:31]** right, so one is task curation and the other one is policy evaluation.

**[00:30:31 – 00:30:33]** So let's start off with task curation.

**[00:30:33 – 00:30:38]** How do we set up an environment inside of Isaac Lab Arena?

**[00:30:38 – 00:30:41]** So we just did this.

**[00:30:42 – 00:30:43]** Let's break it down.

**[00:30:43 – 00:30:49]** So first we want to set up our environment, and then

**[00:30:49 – 00:30:52]** we want to train a policy.

**[00:30:52 – 00:30:55]** We want to see how this policy will evaluate.

**[00:30:55 – 00:30:59]** Now in this course we are going to kind of touch over just

**[00:30:59 – 00:31:01]** two, a couple learning paradigms.

**[00:31:02 – 00:31:05]** So one is an imitation learning workflow, then another one is

**[00:31:05 – 00:31:06]** a reinforcement learning Thank you.

**[00:31:06 – 00:31:10]** But the main gist is that once you have a policy, then

**[00:31:10 – 00:31:13]** you can go into policy evaluation.

**[00:31:13 – 00:31:14]** And this is a cycle, right?

**[00:31:14 – 00:31:18]** So once you train a policy, you evaluate it, you see how

**[00:31:18 – 00:31:19]** well it performs.

**[00:31:19 – 00:31:22]** If it's not as well, then you kind of go back and you

**[00:31:22 – 00:31:25]** train again and then you evaluate and then train again, evaluate.

**[00:31:25 – 00:31:28]** So that's why there is a kind of cycle here where you're kind

**[00:31:28 – 00:31:30]** of like looping back over and over.

**[00:31:30 – 00:31:32]** But step one is let's make sure that that

**[00:31:33 – 00:31:34]** environment is all set up.

**[00:31:34 – 00:31:39]** In this course, this is how we will be breaking this up, so Module

**[00:31:39 – 00:31:43]** 2 will be on Environment Setup, Module 3 will be talking about kind

**[00:31:43 – 00:31:47]** of the overall kind of how to train a policy, and then Module 4 will go

**[00:31:47 – 00:31:49]** over how to evaluate that policy.

**[00:31:49 – 00:31:52]** Let's start with Module 2.

**[00:31:52 – 00:31:56]** So in this course, we will be learning how to do a sequential

**[00:31:56 – 00:32:00]** pick and place task and then a closed door task on this

**[00:32:00 – 00:32:02]** humanoid GR1 here.

**[00:32:02 – 00:32:06]** So you can see that we're interacting with many

**[00:32:06 – 00:32:08]** objects in this scene.

**[00:32:08 – 00:32:12]** So how do we make sure that we set up that environment correctly?

**[00:32:12 – 00:32:15]** So the way that I'm going to break this down today is,

**[00:32:15 – 00:32:17]** first, let's set up our scene.

**[00:32:17 – 00:32:19]** What does our scene kind of encompass?

**[00:32:19 – 00:32:23]** Well, it encompasses an embodiment, a background, some objects.

**[00:32:23 – 00:32:25]** Then we're going to talk about the task.

**[00:32:25 – 00:32:27]** How can we combine two?

**[00:32:27 – 00:32:31]** Separate what we call atomic tasks, I'll go into that a

**[00:32:31 – 00:32:33]** little bit deeper, but how do we combine this pick and

**[00:32:33 – 00:32:36]** place and then a closed-org task?

**[00:32:36 – 00:32:39]** And then finally, in order to set up, we can also talk a little

**[00:32:39 – 00:32:43]** bit about some of the teleoperation devices that we do support.

**[00:32:43 – 00:32:46]** Again, this is, then we pass it into our arena compiler

**[00:32:46 – 00:32:50]** and then we get an Isaac Lab Environment out of that.

**[00:32:50 – 00:32:55]** Cool, so step number one, let's set up our scene.

**[00:32:55 – 00:32:57]** Let's bring in those assets.

**[00:32:57 – 00:33:02]** So just to also help guide you and wanna mention that

**[00:33:02 – 00:33:06]** at the top right corner, I will have kind of where we're at exactly

**[00:33:06 – 00:33:08]** in creating this environment.

**[00:33:08 – 00:33:11]** And then I will also be making note of the kind

**[00:33:11 – 00:33:12]** of file that we're building.

**[00:33:13 – 00:33:15]** And I'm going to go over the code just right now, just so you

**[00:33:15 – 00:33:19]** get a visual perspective of where things are and where things live.

**[00:33:19 – 00:33:21]** And then inside of our virtual machine, we're actually going

**[00:33:21 – 00:33:22]** to go through this by step by step.

**[00:33:23 – 00:33:25]** But I just want you guys to get a conceptual idea of how this works.

**[00:33:26 – 00:33:27]** So, great.

**[00:33:27 – 00:33:30]** Right now, we are going to create a file called

**[00:33:30 – 00:33:34]** GR1PutInClosedDoorEnvironment.py.

**[00:33:34 – 00:33:38]** Step number one, let's bring in our assets.

**[00:33:38 – 00:33:40]** So let's bring in our embodiment, our robot.

**[00:33:40 – 00:33:44]** If you have a USD kind of asset already for that particular

**[00:33:44 – 00:33:46]** robot, feel free to bring that in.

**[00:33:46 – 00:33:48]** We're bringing in our kitchen background here.

**[00:33:48 – 00:33:51]** We're bringing in objects, lights, everything that we need to

**[00:33:51 – 00:33:54]** kind of like encompass our scene.

**[00:33:54 – 00:33:56]** There are many ways that you can do this.

**[00:33:56 – 00:33:58]** You can also set up like a separate object library where

**[00:33:58 – 00:34:01]** you want everything, all of the objects that you kind

**[00:34:01 – 00:34:03]** of want to switch in and out of.

**[00:34:03 – 00:34:06]** You can have a library for that.

**[00:34:06 – 00:34:09]** Or you could just pass it in directly.

**[00:34:11 – 00:34:14]** Once we have our assets all brought in, what's next?

**[00:34:14 – 00:34:20]** Well, we see, for example, in this use case, there is a wrench bottle

**[00:34:20 – 00:34:21]** that we're manipulating with.

**[00:34:21 – 00:34:24]** We're putting it in on a fridge shelf, and then we're

**[00:34:24 – 00:34:26]** closing that door.

**[00:34:26 – 00:34:30]** So that door needs to have an ability to open

**[00:34:30 – 00:34:32]** and close, for example.

**[00:34:32 – 00:34:36]** And so Alex talked about affordances, so it's giving

**[00:34:36 – 00:34:40]** these objects an ability to interact with them.

**[00:34:40 – 00:34:43]** So in this case, we're giving this refrigerator door an

**[00:34:43 – 00:34:45]** openable affordance.

**[00:34:45 – 00:34:49]** So affordances in Arena are if you want to interact with an object,

**[00:34:49 – 00:34:52]** if you want to, let's say if it's a microwave, you want to push

**[00:34:52 – 00:34:55]** a button, then those are different types of affordances because you're

**[00:34:55 – 00:34:57]** interacting with these objects.

**[00:34:58 – 00:35:02]** Now, that, once there is a kind of like affordance, then

**[00:35:02 – 00:35:04]** you want an object reference.

**[00:35:04 – 00:35:07]** So if you can tell, this is a really big kitchen scene.

**[00:35:07 – 00:35:09]** I don't, I'm not gonna be interacting with everything.

**[00:35:09 – 00:35:12]** I'm not gonna be interacting with the stove, with the cabinets,

**[00:35:12 – 00:35:13]** with the shelves.

**[00:35:13 – 00:35:16]** I'm just focused in on my refrigerator.

**[00:35:16 – 00:35:21]** So when I create then an Openable Affordance, I want to make sure

**[00:35:21 – 00:35:25]** then I then pass in a reference that it's going to be secluded

**[00:35:25 – 00:35:29]** to a certain area, and that's the area that I'm using is going

**[00:35:29 – 00:35:33]** to be my refrigerator and that shelf that it's going to live on.

**[00:35:34 – 00:35:39]** Cool, so let's go a little bit into object references.

**[00:35:39 – 00:35:41]** So we've set up an Openable, Affordance.

**[00:35:41 – 00:35:45]** We know that we want our fridge to be openable.

**[00:35:45 – 00:35:50]** So now we've set that reference as well.

**[00:35:50 – 00:35:55]** Now we want that particular refrigerator shelf, right?

**[00:35:55 – 00:35:58]** So then we're gonna create an object reference for that.

**[00:35:58 – 00:36:01]** Then we're going to create a reference also for the kitchen

**[00:36:01 – 00:36:05]** countertop, because that's another area secluded of this entire huge

**[00:36:05 – 00:36:07]** kitchen background that I have.

**[00:36:07 – 00:36:09]** Those are the two points of interest for me.

**[00:36:09 – 00:36:12]** I want to make sure that I set up my pick and place, that

**[00:36:12 – 00:36:17]** area, and then also my place area, which is the refrigerator shelf.

**[00:36:17 – 00:36:21]** Great, so now that I've set up those object preferences,

**[00:36:21 – 00:36:25]** I can then go ahead and add relations to them.

**[00:36:25 – 00:36:28]** So probably in the past, if you've played around with Isaac Sim

**[00:36:28 – 00:36:33]** before or set up any environment, even in Isaac Lab, you need to use

**[00:36:33 – 00:36:35]** X, Y, Z coordinates to make sure.

**[00:36:35 – 00:36:36]** And sometimes you play around with them.

**[00:36:36 – 00:36:38]** I think my object is floating in space.

**[00:36:39 – 00:36:41]** And I have to tweak around these parameters.

**[00:36:41 – 00:36:44]** But now, a really cool thing with Isaac Labarena is that

**[00:36:44 – 00:36:46]** you can add relations to them.

**[00:36:46 – 00:36:50]** So for example, I want this object that I will be working

**[00:36:50 – 00:36:53]** with, manipulating with, to be on the kitchen countertop.

**[00:36:53 – 00:36:56]** So because I created that reference, I can just easily

**[00:36:57 – 00:36:58]** say on the kitchen countertop.

**[00:36:58 – 00:37:02]** If I wanted to place it on a kitchen shelf, I can also do that.

**[00:37:02 – 00:37:05]** I can also place it on a kitchen shelf.

**[00:37:05 – 00:37:11]** We also have other kind of phrases such as like next to, right?

**[00:37:11 – 00:37:16]** And so this allows us to easily kind of switch and play around.

**[00:37:16 – 00:37:19]** You can also fixate if you want at a certain place.

**[00:37:19 – 00:37:20]** So we have an app position.

**[00:37:20 – 00:37:23]** So if there's a certain position that you want it

**[00:37:23 – 00:37:24]** to always create in.

**[00:37:25 – 00:37:30]** But we also, something that, for

**[00:37:30 – 00:37:36]** data, or just kind of setting up your scene, you want to randomize

**[00:37:36 – 00:37:41]** the initial position and where an object is spawned, in a sense.

**[00:37:41 – 00:37:46]** Because you want your policy to learn to not only be so constrained

**[00:37:46 – 00:37:48]** onto one specific location,

**[00:37:48 – 00:37:52]** It should be able to grasp from any kind of range.

**[00:37:52 – 00:37:56]** And so what we're doing here is we're also adding a pickup.

**[00:37:56 – 00:38:01]** If you see here, we're actually adding some randomization

**[00:38:01 – 00:38:06]** as to kind of the orientation and the position where it can live in.

**[00:38:06 – 00:38:11]** Great, so finally we tie that all together at the bottom

**[00:38:11 – 00:38:12]** where we bring in our scene.

**[00:38:12 – 00:38:15]** So we bring in that kitchen background, that kitchen

**[00:38:15 – 00:38:17]** countertop, the objects that we're gonna pick up,

**[00:38:17 – 00:38:19]** the light, refrigerator, and refrigerator shelf.

**[00:38:19 – 00:38:24]** Those are all the kind of objects of interest for our particular

**[00:38:24 – 00:38:26]** environment that we want to build.

**[00:38:26 – 00:38:30]** Cool, so now we've created our scene.

**[00:38:31 – 00:38:35]** I wanted to highlight again this relational object placement.

**[00:38:35 – 00:38:38]** In the future, you can see how this can easily scale

**[00:38:39 – 00:38:44]** into having agents use some LLM to create just instead

**[00:38:44 – 00:38:47]** of an on or next to reference.

**[00:38:47 – 00:38:51]** And so that's a really good, powerful tool that we can

**[00:38:51 – 00:38:56]** So you can see ARENA kind of moving towards in that direction.

**[00:38:56 – 00:38:59]** But yeah, so scene tying everything all together, bringing in

**[00:38:59 – 00:39:04]** all of our assets, and we're good to go for our scene.

**[00:39:04 – 00:39:07]** Now that's just the scene, right?

**[00:39:08 – 00:39:11]** So we want to let's talk about task.

**[00:39:11 – 00:39:14]** We want to make sure that our how do we make sure that

**[00:39:14 – 00:39:16]** our robot now is able to go ahead Let's go ahead and pick

**[00:39:16 – 00:39:19]** up that object and place it down.

**[00:39:19 – 00:39:24]** So Alex and Sangeeta kind of introduced kind of what

**[00:39:24 – 00:39:28]** task was, and there's atomic tasks.

**[00:39:28 – 00:39:29]** I mentioned that word before.

**[00:39:29 – 00:39:34]** So atomic tasks are things like just a closed door, pick

**[00:39:34 – 00:39:37]** and place, open door, press button.

**[00:39:37 – 00:39:41]** And so these obviously we want, those are kind of

**[00:39:41 – 00:39:42]** small-scale tasks.

**[00:39:42 – 00:39:45]** When we're thinking about how we want to scale this up

**[00:39:45 – 00:39:50]** into a more complex task, we want I want to kind of change, chain.

**[00:39:51 – 00:40:05]** We want to make sure that we record a scene when a door is closed.

**[00:40:05 – 00:40:08]** We want to make sure that that's a success.

**[00:40:08 – 00:40:11]** We also want to make sure that it's a failure when our object

**[00:40:11 – 00:40:14]** has fallen from the fridge Or when we haven't placed it properly.

**[00:40:14 – 00:40:16]** We want to reset our actions.

**[00:40:16 – 00:40:21]** So all of these kind of these success metrics can all be

**[00:40:21 – 00:40:24]** set up inside of a task.

**[00:40:24 – 00:40:28]** So now that we've looked a little bit into kind of atomic

**[00:40:28 – 00:40:33]** tasks, now let's kind of chain those tasks together.

**[00:40:33 – 00:40:39]** So on my right, I have the, again, we're still sticking

**[00:40:39 – 00:40:43]** on my GR1 put and close the door Or environment.py.

**[00:40:43 – 00:40:46]** So on this side, it looks very clean.

**[00:40:46 – 00:40:50]** It looks very nice, where I just do a pick and place task.

**[00:40:50 – 00:40:53]** I am setting up what I want my pickup object to be, the

**[00:40:53 – 00:40:57]** destination, the destination location, and the background.

**[00:40:57 – 00:41:00]** Then I want to create a closed door task.

**[00:41:00 – 00:41:04]** Where I'm setting the closeness threshold and the reset openness.

**[00:41:04 – 00:41:08]** So every single time here, my scene kind of, I'm telling,

**[00:41:08 – 00:41:12]** okay, the refrigerator should be open at a certain angle.

**[00:41:12 – 00:41:15]** There's a certain threshold that I want it to meet when it's closed.

**[00:41:15 – 00:41:19]** Then a sequential task is putting, it's chaining all

**[00:41:19 – 00:41:20]** of these subtasks together.

**[00:41:21 – 00:41:23]** And, um...

**[00:41:25 – 00:41:29]** Yeah, it's chaining all of these subtasks together and combining

**[00:41:29 – 00:41:33]** all of these atomic tasks into one.

**[00:41:33 – 00:41:36]** I wanted to take some time and go through kind of just

**[00:41:36 – 00:41:39]** the pick and place task, for example, where you can, I

**[00:41:39 – 00:41:42]** talked about how to make sure that our scene kind of like ends

**[00:41:42 – 00:41:48]** or what is, how do I define whether it's a success or a failure?

**[00:41:48 – 00:41:53]** Well, I can, in my pick and place task now on the left here,

**[00:41:53 – 00:41:56]** I can talk about, okay, what is a success, what are my termination

**[00:41:56 – 00:42:02]** criterias, is there a certain kind of velocity that I wanted

**[00:42:02 – 00:42:07]** to go at, but inside of these particular pick and place tasks

**[00:42:07 – 00:42:12]** is where you define kind of what you want your success metric to be.

**[00:42:12 – 00:42:16]** So, same thing for closed door, make a termination config

**[00:42:16 – 00:42:20]** file, what is, what do we consider as something that

**[00:42:20 – 00:42:23]** is a success or a failure.

**[00:42:23 – 00:42:27]** And so once we've combined all of these tasks, then we've

**[00:42:27 – 00:42:30]** kind of completed that second portion of our, of what we need

**[00:42:30 – 00:42:32]** in order to create an environment.

**[00:42:32 – 00:42:36]** Scene, task, and then finally, let's look into

**[00:42:36 – 00:42:38]** Teleoperation Device.

**[00:42:38 – 00:42:44]** Okay, so Isaac Lab Arena also allows for the ability for

**[00:42:44 – 00:42:49]** you to collect your own data inside of your simulated environment.

**[00:42:49 – 00:42:51]** We currently have these teleoperation

**[00:42:51 – 00:42:52]** devices that we support.

**[00:42:52 – 00:42:55]** There is more information on teleop that can be found

**[00:42:55 – 00:42:56]** inside of this QR code.

**[00:42:56 – 00:43:00]** This will take you to our Isaac Lab documentation where

**[00:43:00 – 00:43:03]** we have support for

**[00:43:03 – 00:43:05]** More just in-depth documentation on how you can set this

**[00:43:05 – 00:43:07]** up for your scene.

**[00:43:08 – 00:43:12]** But essentially, on the kind of environment side, you kind

**[00:43:12 – 00:43:17]** of set whether you want a teleop device or not, and then, yeah,

**[00:43:17 – 00:43:20]** you also register that environment.

**[00:43:20 – 00:43:22]** More information on that later.

**[00:43:22 – 00:43:25]** For this course, we do not have time to go into all of

**[00:43:25 – 00:43:29]** that in depth, but providing all of the documentation there

**[00:43:29 – 00:43:31]** for your use case.

**[00:43:31 – 00:43:34]** So now, let's tie it all together for this Isaac

**[00:43:34 – 00:43:36]** Lab Arena Environment, we're then going to bring in our

**[00:43:36 – 00:43:40]** embodiment that we had, the scene that we had, the sequential

**[00:43:40 – 00:43:45]** task that we created, and a tele-op device, and then we return

**[00:43:45 – 00:43:49]** that, we pass that into an arena compiler, and then that should

**[00:43:49 – 00:43:52]** give us an Isaac Lab Environment.

**[00:43:53 – 00:43:56]** I will be going over, we're going to be looking at this visually

**[00:43:56 – 00:44:00]** in just a second, but I wanted to also take a moment to step back.

**[00:44:00 – 00:44:04]** We have just created this environment for one scene, right?

**[00:44:04 – 00:44:08]** So does this only work for just this particular robot?

**[00:44:08 – 00:44:10]** What if I wanted to bring in a manipulator?

**[00:44:10 – 00:44:12]** What if I wanted to bring another G1?

**[00:44:12 – 00:44:15]** Do I have to go through this all over again?

**[00:44:15 – 00:44:17]** The answer is no.

**[00:44:17 – 00:44:20]** With Arena, that's what's really great.

**[00:44:20 – 00:44:22]** All of these pieces are modular, right?

**[00:44:22 – 00:44:26]** So that's why you can just pass in a different embodiment

**[00:44:26 – 00:44:29]** here without having to rewrite your code, because you still

**[00:44:29 – 00:44:30]** want that same environment.

**[00:44:30 – 00:44:32]** You still want that same refrigerator.

**[00:44:32 – 00:44:34]** You just want a different

**[00:44:34 – 00:44:37]** Embodiment now. Or let's say instead of picking that ranch

**[00:44:37 – 00:44:40]** bottle, you want to pick up an apple instead.

**[00:44:40 – 00:44:42]** All of this can be easily swapped, and we're going to

**[00:44:42 – 00:44:43]** see how to do that.

**[00:44:43 – 00:44:47]** So the real power with that is we're able to scale from

**[00:44:47 – 00:44:50]** one to n amount of tasks.

**[00:44:50 – 00:44:53]** And let's actually look at how we can do that.

**[00:44:53 – 00:45:01]** So let's go back to the kind of scene that we had set up.

**[00:45:01 – 00:45:05]** If we can switch scenes.

**[00:45:05 – 00:45:10]** Yeah, let's switch screens.

**[00:45:10 – 00:45:15]** So if everybody could go back to what we had run earlier, I will

**[00:45:15 – 00:45:18]** show this on my screen as well.

**[00:45:20 – 00:45:22]** Okay, perfect.

**[00:45:22 – 00:45:26]** If everybody could go back to where we were just at.

**[00:45:26 – 00:45:29]** I had told you guys to leave something running in the

**[00:45:29 – 00:45:33]** background, but essentially that's the exact scene that

**[00:45:33 – 00:45:35]** I kind of like walked over.

**[00:45:35 – 00:45:37]** I want you guys, you guys have a mouse.

**[00:45:37 – 00:45:39]** You can also look at this scene, right?

**[00:45:39 – 00:45:43]** If you guys scroll, press right click, and just kind

**[00:45:44 – 00:45:47]** of drag, press and hold that right click, you can look

**[00:45:48 – 00:45:51]** around your scene, how it looks like, the objects that you have.

**[00:45:51 – 00:45:54]** You can scroll, zoom in and zoom out.

**[00:45:54 – 00:45:57]** You can see that it's a ranch bottle, right?

**[00:45:58 – 00:46:00]** Let's go ahead.

**[00:46:05 – 00:46:08]** So, yeah.

**[00:46:09 – 00:46:15]** Let's now, OK, so if you guys are seeing this, this is good.

**[00:46:15 – 00:46:18]** Please let TAs know if you guys are not, because we're

**[00:46:18 – 00:46:21]** going to build from here on out.

**[00:46:21 – 00:46:25]** So from here, let's go ahead and kill this.

**[00:46:25 – 00:46:27]** And let's bring in something new.

**[00:46:27 – 00:46:30]** So I'm going to do that by pressing Control-C.

**[00:46:30 – 00:46:34]** Going back to my documentation here, I'm going to go now

**[00:46:34 – 00:46:38]** to Environment Setup.

**[00:46:38 – 00:46:42]** There's a hands-on portion, so just making this bigger

**[00:46:42 – 00:46:45]** so that you guys can see.

**[00:46:45 – 00:46:49]** Let's go to the 1 through N task scaling hands-on

**[00:46:49 – 00:46:51]** portion of this course.

**[00:46:51 – 00:46:56]** So I want you guys, so let's look at that.

**[00:46:56 – 00:46:59]** Let's look at the...

**[00:46:59 – 00:47:01]** Let's open up the code that we were just going through.

**[00:47:01 – 00:47:05]** So there's Isaac Lab Arena Environments here on the right.

**[00:47:05 – 00:47:06]** Can you guys see that?

**[00:47:06 – 00:47:08]** I can also make it a little bit bigger.

**[00:47:08 – 00:47:11]** I just want to make sure that... Okay, cool.

**[00:47:11 – 00:47:12]** I think that's a little bit better.

**[00:47:13 – 00:47:15]** So if you guys go to Isaac Lab Arena Environments, and

**[00:47:15 – 00:47:19]** then you guys go into GR1 Put and Close Door Environment,

**[00:47:19 – 00:47:22]** this will actually contain all of the code that I just went through

**[00:47:22 – 00:47:24]** and I broke down into pieces.

**[00:47:24 – 00:47:28]** You'll see how this has...

**[00:47:28 – 00:47:31]** I can't scroll.

**[00:47:33 – 00:47:36]** It's a tiny screen here.

**[00:47:37 – 00:47:39]** We have...

**[00:47:40 – 00:47:44]** We see... Oops.

**[00:47:46 – 00:47:49]** We see how we have our embodiments, the kitchen background, the

**[00:47:49 – 00:47:51]** kitchen countertop.

**[00:47:52 – 00:48:00]** We see the object references, the tasks.

**[00:48:03 – 00:48:06]** OK, cool.

**[00:48:06 – 00:48:09]** Let's go ahead and focus on task number one.

**[00:48:09 – 00:48:11]** So instead of the ranch bottle that we had originally set

**[00:48:11 – 00:48:15]** up, I want you to bring in a different object in.

**[00:48:15 – 00:48:18]** Here's a list of objects that you can kind of play around with.

**[00:48:18 – 00:48:21]** Go ahead and choose any of these objects from this object

**[00:48:21 – 00:48:24]** list and bring it up in your scene.

**[00:48:24 – 00:48:27]** So the way that you would do that, choose an object.

**[00:48:27 – 00:48:31]** And in the command that we ran, you kind of I want to

**[00:48:31 – 00:48:34]** substitute that in right here.

**[00:48:34 – 00:48:38]** So go ahead and try doing that on your end.

**[00:48:41 – 00:48:43]** I'll do that too.

**[00:49:45 – 00:49:47]** Thank you.

**[00:50:18 – 00:50:21]** If you're waiting for that to run, go ahead and just wait.

**[00:50:21 – 00:50:25]** I can move on to the second task because I really want

**[00:50:25 – 00:50:29]** you guys to make sure, I know we're running a little late on time,

**[00:50:29 – 00:50:33]** but the second task is, okay, now with that object that you're going

**[00:50:33 – 00:50:37]** to bring in, how do I modify the refrigerator door to be a little

**[00:50:37 – 00:50:39]** bit open at a much wider angle?

**[00:50:39 – 00:50:41]** How do I bring in a different embodiment?

**[00:50:41 – 00:50:45]** How do, in this case, let's try to bring in a manipulator, a Franka.

**[00:50:46 – 00:50:48]** Let me try using a keyboard as a teleoperation device,

**[00:50:48 – 00:50:52]** and then I will also try to place this object instead of

**[00:50:52 – 00:51:00]** on the kitchen counter table, let's try to put it on a shelf instead.

**[00:51:01 – 00:51:03]** So, in order to do that, if you guys want to pay

**[00:51:03 – 00:51:06]** attention to me while you guys are letting that run,

**[00:51:06 – 00:51:08]** it's going to take a quick second.

**[00:51:08 – 00:51:13]** So let's see how we can accomplish all of these tasks.

**[00:51:13 – 00:51:19]** So going back to the code here, we talked about how let's

**[00:51:19 – 00:51:23]** look at where we can set up The

**[00:51:24 – 00:51:27]** If you want to follow along, I just want to let you know, I

**[00:51:27 – 00:51:29]** have placed the answers right here.

**[00:51:30 – 00:51:32]** This mouse is very finicky.

**[00:51:32 – 00:51:35]** I do have an answer toggle here that if you want to follow

**[00:51:35 – 00:51:38]** along, you totally can.

**[00:51:38 – 00:51:40]** So let's modify this refrigerator door angle.

**[00:51:40 – 00:51:43]** Let's go to line 138.

**[00:51:43 – 00:51:48]** On our GR1 put in closed-door environment.py, so let's scroll

**[00:51:48 – 00:51:50]** a little bit down, 138.

**[00:51:51 – 00:51:54]** We see that here. I mentioned this openable threshold.

**[00:51:54 – 00:51:56]** Let's go ahead and open that instead.

**[00:51:56 – 00:52:00]** Let's make that 0.8, or you can make it narrower, too, but

**[00:52:00 – 00:52:02]** let's play around with that value.

**[00:52:02 – 00:52:03]** Let me save that.

**[00:52:03 – 00:52:10]** Next, let's go ahead and bring in a different embodiment.

**[00:52:10 – 00:52:14]** So the way that we do that is, in Isaac Laberina, we

**[00:52:14 – 00:52:19]** have an asset library of different kind of embodiments, so all

**[00:52:19 – 00:52:23]** we need to do is, when in our final command, we want to add

**[00:52:23 – 00:52:29]** Franka Yeah, instead of the GR1.

**[00:52:30 – 00:52:35]** Let's see how we can spawn the object on a cabinet shelf instead

**[00:52:35 – 00:52:40]** of the current table that we had.

**[00:52:40 – 00:52:45]** So in here, we had a refrigerator shelf object reference, right?

**[00:52:45 – 00:52:49]** But now, let's try to do something different.

**[00:52:51 – 00:52:55]** Let's go ahead and copy this line here, place it

**[00:52:55 – 00:52:58]** after line 153, paste.

**[00:53:04 – 00:53:08]** Uh, time.

**[00:53:15 – 00:53:21]** Okay, and then adding this to be cab board.

**[00:53:28 – 00:53:32]** Great, and then...

**[00:53:33 – 00:53:35]** Yeah, that looks good to me.

**[00:53:35 – 00:53:40]** And then finally, we need to add cab board back to our scene.

**[00:53:40 – 00:53:42]** So if we go back to all of these assets, I'm just going to put it

**[00:53:42 – 00:53:47]** at the beginning here, cab board.

**[00:53:49 – 00:53:54]** Hopefully this is, and while I've made those changes, I

**[00:53:54 – 00:53:56]** have had my other environment running in the background and

**[00:53:56 – 00:53:59]** now I've loaded a mustard bottle.

**[00:53:59 – 00:54:02]** So it's really quite easy once you've brought in all of those

**[00:54:02 – 00:54:05]** assets, you can literally swap.

**[00:54:05 – 00:54:09]** Like super quickly, in and out, as to what object you want.

**[00:54:09 – 00:54:14]** Let me go ahead and kill this and run the current example that I had

**[00:54:14 – 00:54:17]** just done, just so that we can see.

**[00:54:17 – 00:54:21]** So here instead, I'll keep a mustard bottle, but instead

**[00:54:21 – 00:54:27]** of the embodiment tag right here, I want a Franka robot.

**[00:54:31 – 00:54:33]** I'll leave this running in the background as well.

**[00:54:33 – 00:54:38]** It's going to take some time, so I kind of just wanted to go through

**[00:54:38 – 00:54:40]** the next module really quick.

**[00:54:40 – 00:54:45]** But just to kind of close, I'll leave this running.

**[00:54:45 – 00:54:50]** But just to kind of really just close out here, we kind of covered

**[00:54:50 – 00:54:54]** the first two iterations of this.

**[00:54:54 – 00:54:56]** Everything that Arena can offer, right?

**[00:54:56 – 00:54:58]** So we've created a task.

**[00:54:58 – 00:55:02]** We've learned how we can also scale that task from one to

**[00:55:02 – 00:55:03]** n different amounts.

**[00:55:03 – 00:55:05]** You can swap in objects easily now.

**[00:55:05 – 00:55:09]** You can create different environments, backgrounds.

**[00:55:09 – 00:55:13]** Now that we've created that environment, what's next?

**[00:55:13 – 00:55:20]** Well, let's look at how we can look into training a policy.

**[00:55:21 – 00:55:29]** Yeah, okay, so this, I just want to make sure everything's up.

**[00:55:30 – 00:55:33]** Oh yeah, keyboard.

**[00:55:36 – 00:55:39]** Okay, again, running in the background.

**[00:55:39 – 00:55:42]** So the biggest thing that once we've set up our environment,

**[00:55:42 – 00:55:45]** let's look into kind of training a policy.

**[00:55:45 – 00:55:49]** So in this course, because, again, we are running out of time, this

**[00:55:50 – 00:55:54]** is very quickly, there are a couple of different learning paradigms.

**[00:55:54 – 00:55:58]** You've probably heard of imitation learning, reinforcement learning,

**[00:55:59 – 00:56:01]** and let's see how This is how we can kind of use the

**[00:56:01 – 00:56:04]** environment that we just made to

**[00:56:04 – 00:56:07]** And tap into each of those different learning paradigms.

**[00:56:07 – 00:56:11]** So Isaac Lab Arena is an extension of Isaac Lab.

**[00:56:12 – 00:56:16]** So when you've created an Isaac Lab Arena, what you've done is you've

**[00:56:16 – 00:56:20]** actually created a manager-based RL environment inside of Isaac Lab.

**[00:56:20 – 00:56:23]** So Isaac Lab is a robot learning platform.

**[00:56:23 – 00:56:27]** So in there, in the Isaac Lab RL environment, if you've

**[00:56:27 – 00:56:30]** played around with Isaac Lab before, then all of those kind of

**[00:56:30 – 00:56:34]** like goodies that you have inside of Isaac Lab, you are now able

**[00:56:34 – 00:56:38]** to use those with the Isaac Lab Arena environment that you created.

**[00:56:38 – 00:56:42]** For imitation learning, this is an example workflow.

**[00:56:42 – 00:56:46]** You can use this or any other workflow of your choice.

**[00:56:46 – 00:56:49]** Data capture with Isaac Lab Teleop, you can use any XR

**[00:56:49 – 00:56:54]** device to record some demos inside of Isaac Sim.

**[00:56:54 – 00:56:58]** You can augment data either using Cosmos, using Isaac Lab Mimic,

**[00:56:58 – 00:57:02]** or any other custom synthetic data generation tool of your choice.

**[00:57:02 – 00:57:05]** And then you can train a policy, whether that's GROOT,

**[00:57:05 – 00:57:12]** Whether that's GROOT, whether that's physical like PI0 VLA,

**[00:57:12 – 00:57:15]** all of these, you are able to bring them in and you can

**[00:57:15 – 00:57:17]** train a policy with that.

**[00:57:17 – 00:57:19]** Then there's also reinforcement learning.

**[00:57:19 – 00:57:23]** So again, because the Isaac Lab Arena Environment extends

**[00:57:23 – 00:57:28]** from Isaac Lab, you can train a policy with some of the learning

**[00:57:28 – 00:57:30]** libraries like SKRL, RSLRL.

**[00:57:31 – 00:57:35]** So there is a QR code here for how to do that RL training

**[00:57:35 – 00:57:37]** inside of Isaac Lab.

**[00:57:37 – 00:57:41]** But regardless, that kind of ties up that second kind

**[00:57:41 – 00:57:45]** of component that we're needing, which is how do we train a policy.

**[00:57:45 – 00:57:49]** For our lab, we have already brought in a policy.

**[00:57:49 – 00:57:51]** We have some checkpoints already loaded into that virtual machine,

**[00:57:51 – 00:57:58]** and we will learn how to tap into that for this final course here.

**[00:57:58 – 00:58:04]** But I just kind of wanted to close off with, we now have a Franka

**[00:58:04 – 00:58:09]** robot inside of our scene, mustard bottle, and yeah, we've kind

**[00:58:09 – 00:58:11]** of like opened that refrigerator door a little bit more.

**[00:58:11 – 00:58:16]** So with that, I'm going to pass it on to Asawari to cover

**[00:58:16 – 00:58:20]** the next portion of this course.

**[00:58:30 – 00:58:31]** Maybe we didn't change it.

**[00:58:31 – 00:58:33]** Yeah, I think I was rushing through it.

**[00:58:34 – 00:58:37]** Maybe she didn't save the file.

**[00:58:38 – 00:58:39]** Excellent. Okay, thank you, Edith.

**[00:58:39 – 00:58:42]** So we just took a quick look into how to set up the scene

**[00:58:42 – 00:58:44]** and the environment and get this policy started.

**[00:58:44 – 00:58:47]** And then we also looked into a quick how to post-train and

**[00:58:48 – 00:58:49]** do teleop in the entire pipeline.

**[00:58:49 – 00:58:52]** Now let's get to the part where we have a policy.

**[00:58:52 – 00:58:54]** And let's see that now we want to actually evaluate

**[00:58:54 – 00:58:57]** it and see how well it performs across different scenarios.

**[00:58:57 – 00:59:00]** So, let's actually stay in our virtual environment over

**[00:59:00 – 00:59:03]** here, and some of you have already started this, so that's good

**[00:59:03 – 00:59:07]** to see, but you can basically go over to your terminal and control

**[00:59:07 – 00:59:10]** C, or you can kill that application that we were just running,

**[00:59:10 – 00:59:13]** and go back to your documentation, and in the panel, go ahead

**[00:59:13 – 00:59:16]** and click on evaluate at scale, which is where I am right now.

**[00:59:17 – 00:59:19]** So, this entire page, this section, is about evaluating the

**[00:59:19 – 00:59:22]** policy that we've trained so far.

**[00:59:22 – 00:59:26]** Now, a couple of metrics over here, let me walk through them while we

**[00:59:26 – 00:59:28]** actually run the evaluation script.

**[00:59:28 – 00:59:33]** So, if you scroll down, you'll see a section that says single

**[00:59:33 – 00:59:34]** environment evaluation.

**[00:59:34 – 00:59:36]** This is what we're going to do first and then move on

**[00:59:36 – 00:59:38]** to parallel evaluation.

**[00:59:38 – 00:59:41]** Go ahead and copy that entire command that I'm copying at

**[00:59:41 – 00:59:46]** the bottom, step 4, that says run a single environment evaluation.

**[00:59:46 – 00:59:50]** Go ahead and copy that in your terminal.

**[00:59:50 – 00:59:53]** And the object that you see here is the ranch dressing bottle,

**[00:59:53 – 00:59:55]** that's the model that we're, that's the policy we're evaluating.

**[00:59:55 – 00:59:57]** So we've trained, like imagine you're at the stage where

**[00:59:57 – 01:00:00]** you've already trained a policy to be able to pick and put

**[01:00:01 – 01:00:02]** in the fridge this ranch bottle.

**[01:00:02 – 01:00:04]** We're running that policy as specified

**[01:00:04 – 01:00:06]** in the config file over here.

**[01:00:06 – 01:00:08]** I'll show you what that looks like in a minute as well.

**[01:00:08 – 01:00:12]** But you can go ahead and run this command.

**[01:00:12 – 01:00:16]** Now, at the end of this, what you'll see is, on your terminal,

**[01:00:16 – 01:00:19]** you'll see a printed output of the evaluation metrics.

**[01:00:19 – 01:00:23]** I'll explain what these metrics are, so just make sure you've

**[01:00:23 – 01:00:26]** gone ahead and run that command, and it'll take a minute to

**[01:00:26 – 01:00:28]** just kind of load that scene again.

**[01:00:28 – 01:00:31]** And it's going to be the humanoid scene, where we had the GR1

**[01:00:31 – 01:00:35]** robot, and it'll be interacting with the ranch bottle.

**[01:00:36 – 01:00:39]** Okay, so...

**[01:00:44 – 01:00:45]** Excellent.

**[01:00:45 – 01:00:47]** So I'm going to talk to you a little bit first about

**[01:00:47 – 01:00:48]** the output metrics.

**[01:00:48 – 01:00:51]** These are important to know because in our example, we just

**[01:00:51 – 01:00:55]** specify a few that you'll see, but the whole idea of using Isaac Lab

**[01:00:55 – 01:00:58]** Arena is that these are extensible metrics, which means that you can

**[01:00:58 – 01:01:02]** kind of define your own that are most appropriate for the task and

**[01:01:02 – 01:01:04]** the policy that you're evaluating, and you can specify those

**[01:01:05 – 01:01:06]** through the use of config files.

**[01:01:06 – 01:01:09]** Now, some quick metrics examples that we're seeing in this

**[01:01:09 – 01:01:12]** sample that we're running today, the success rate for

**[01:01:12 – 01:01:14]** the entire sequential task, so that's the end-to-end,

**[01:01:14 – 01:01:17]** from picking up and from grasping the object to placing it in

**[01:01:17 – 01:01:20]** the fridge and closing the door, success rate for the whole thing.

**[01:01:20 – 01:01:23]** But you also can get more granular metrics.

**[01:01:23 – 01:01:25]** So, for example, you can see the success rate for the first

**[01:01:25 – 01:01:28]** part of this task, which is that subtask of actually grasping

**[01:01:28 – 01:01:30]** and putting in the fridge.

**[01:01:30 – 01:01:34]** Then you can see the success rate for the second subtask.

**[01:01:34 – 01:01:36]** Sorry, which is closing the fridge door.

**[01:01:36 – 01:01:40]** And in this way, you can define all those individual subtasks that

**[01:01:40 – 01:01:42]** you want to measure metrics for.

**[01:01:42 – 01:01:45]** Now, why this helps is obviously that this kind of granular

**[01:01:45 – 01:01:48]** knowledge gives you very actionable insights into which part of the

**[01:01:48 – 01:01:50]** pipeline you have to improve on.

**[01:01:50 – 01:01:52]** So if it shows up that the first subtask is performing

**[01:01:52 – 01:01:55]** much better than the second, then you kind of know that,

**[01:01:55 – 01:01:57]** OK, maybe you have to train or collect better samples for that

**[01:01:57 – 01:02:00]** first half or the first subtask.

**[01:02:00 – 01:02:02]** So that's basically a quick breakdown of some of these

**[01:02:02 – 01:02:04]** metrics and the fact that they are extensible so you can

**[01:02:04 – 01:02:07]** actually define your own metrics.

**[01:02:08 – 01:02:12]** I'm switching back over to my terminal, and apologies

**[01:02:12 – 01:02:14]** that I think it was running while I was on the slides,

**[01:02:14 – 01:02:16]** but I do want to highlight the metrics that we see here.

**[01:02:16 – 01:02:19]** So kind of what I just described, you see the end-to-end success

**[01:02:19 – 01:02:21]** rate and the subtask success rate.

**[01:02:21 – 01:02:24]** Here the first one, object moved rate, is the grasping of the

**[01:02:24 – 01:02:27]** object, and the second, which is revolute joint move, that actually

**[01:02:27 – 01:02:31]** measures your door closing, so the angle of the door changing.

**[01:02:32 – 01:02:38]** So, let me actually run that again and stay on this screen

**[01:02:38 – 01:02:40]** so that we can all kind of take a look at that together.

**[01:02:40 – 01:02:44]** What it's going to look like is basically it will play an episode.

**[01:02:44 – 01:02:46]** So, it will show the robot doing that exact task that

**[01:02:46 – 01:02:48]** we've trained it to do.

**[01:02:48 – 01:02:50]** And visually, that's what we see, of course, on the GUI.

**[01:02:50 – 01:02:53]** What's happening in the background is these metrics are actually

**[01:02:53 – 01:02:55]** being calculated.

**[01:02:55 – 01:02:56]** Now, you'll notice that a couple of arguments we

**[01:02:57 – 01:02:59]** mentioned in the command.

**[01:02:59 – 01:03:01]** The number of steps, for example, here.

**[01:03:01 – 01:03:03]** By default, I've set it at 500.

**[01:03:03 – 01:03:05]** If you want, you can increase it.

**[01:03:05 – 01:03:08]** That just means more steps for evaluation.

**[01:03:08 – 01:03:12]** And let me go back to my SIM window.

**[01:03:13 – 01:03:15]** Give it a minute to load.

**[01:03:17 – 01:03:19]** Excellent, okay.

**[01:03:19 – 01:03:22]** And this is what you'll see, just the task playing out.

**[01:03:22 – 01:03:26]** I'll just zoom in a little bit more.

**[01:03:27 – 01:03:31]** Okay, so we already got a chance to look at what the

**[01:03:31 – 01:03:32]** output metrics look like.

**[01:03:32 – 01:03:35]** So I think I'll go ahead and kill this command because

**[01:03:35 – 01:03:39]** what I want to show you next is the parallel evaluation.

**[01:03:39 – 01:03:44]** So let's go down, scroll down to parallel environment evaluation.

**[01:03:44 – 01:03:46]** You can run this command if you want, I'm not going to because

**[01:03:46 – 01:03:48]** I'm going to run the next one.

**[01:03:48 – 01:03:50]** But I will explain what we're seeing here.

**[01:03:50 – 01:03:54]** So in parallel environment evaluation, you have the same one

**[01:03:54 – 01:03:58]** window that we saw right now, that, but into a certain number of times.

**[01:03:58 – 01:04:00]** That's something that you can define, and we define it

**[01:04:00 – 01:04:02]** here through the numenvs argument.

**[01:04:02 – 01:04:04]** That's just the number of environments.

**[01:04:04 – 01:04:08]** So I'm going to copy, or instead of running this one, I'm actually

**[01:04:08 – 01:04:09]** going to go down.

**[01:04:09 – 01:04:12]** The difference between the parallel environment evaluation

**[01:04:12 – 01:04:15]** and the one right below it that you see, multi-object heterogeneous,

**[01:04:15 – 01:04:18]** in both cases there are a number of parallel environments.

**[01:04:18 – 01:04:20]** The difference is, in the first case, it's only going

**[01:04:20 – 01:04:24]** to spawn the ranch dressing bottle in all your parallel environments.

**[01:04:24 – 01:04:27]** Whereas in the second one, as the name suggests, for multi-object

**[01:04:27 – 01:04:30]** it will actually be within a range of objects that you specify.

**[01:04:30 – 01:04:33]** So if you look at the object set argument down here,

**[01:04:33 – 01:04:35]** I'm highlighting it, it has a bunch of stuff.

**[01:04:35 – 01:04:39]** It has the ketchup bottle, ranch bottle, barbecue and mayonnaise.

**[01:04:39 – 01:04:42]** So all of these bottles, same task again, just want to pick

**[01:04:42 – 01:04:44]** it, place it in the fridge and close the door.

**[01:04:44 – 01:04:46]** But each environment will spawn a different one.

**[01:04:46 – 01:04:48]** So this is more fun to see.

**[01:04:48 – 01:04:50]** I'm going to go ahead and copy that command.

**[01:04:50 – 01:04:52]** And you can follow, you can do it as well.

**[01:04:52 – 01:04:55]** Copy that into your workspace.

**[01:04:55 – 01:04:57]** And that's it. Go ahead and run it.

**[01:04:57 – 01:05:01]** So because here we've specified the number of environments

**[01:05:01 – 01:05:05]** to be 10, we'll actually see 10 identical environments spawned.

**[01:05:05 – 01:05:09]** Not identical, the objects will be different in each.

**[01:05:10 – 01:05:12]** The model, the policy that we're evaluating here is kind

**[01:05:12 – 01:05:14]** of the one we've been working with all this time.

**[01:05:14 – 01:05:17]** So it's going to be the policy for the ranch bottle, but you can run

**[01:05:17 – 01:05:19]** it for these other objects as well.

**[01:05:19 – 01:05:22]** And the only kind of prerequisite is that you need to make sure

**[01:05:22 – 01:05:25]** that those objects are registered in your library so that it

**[01:05:25 – 01:05:28]** knows what object to spawn in sim.

**[01:05:30 – 01:05:33]** Give it just a minute, and this is really fun to see,

**[01:05:33 – 01:05:37]** because once it loads, you can zoom out, and controls on how to

**[01:05:37 – 01:05:39]** zoom out are in your documentation.

**[01:05:39 – 01:05:42]** So if you go back to your documentation and scroll up

**[01:05:42 – 01:05:48]** on the same page a little bit, you will see...

**[01:05:49 – 01:05:51]** You will see this. It's a small note on simulation

**[01:05:51 – 01:05:53]** viewport controls.

**[01:05:53 – 01:05:55]** So you all have a mouse, so you can basically do the right

**[01:05:56 – 01:05:59]** click, and along with right click at the same time, do like W and

**[01:05:59 – 01:06:03]** S to zoom in and out, or A and D to move right and left in your scene.

**[01:06:03 – 01:06:07]** And I'll be doing that as well, so you can see how that looks.

**[01:06:10 – 01:06:11]** Let me increase my viewport, actually,

**[01:06:11 – 01:06:15]** so you guys get a good view.

**[01:06:16 – 01:06:17]** Excellent. So this is one environment.

**[01:06:17 – 01:06:20]** Looks kind of the same like the previous example we ran,

**[01:06:20 – 01:06:21]** but I'm going to zoom out now.

**[01:06:21 – 01:06:23]** And as I zoom out, you'll get to see all these

**[01:06:23 – 01:06:24]** parallel environments.

**[01:06:24 – 01:06:27]** We have 10 running right now.

**[01:06:27 – 01:06:31]** And you can kind of zoom into any one of them as well.

**[01:06:31 – 01:06:36]** I'll go ahead and focus in on one environment.

**[01:06:40 – 01:06:43]** Excellent.

**[01:06:47 – 01:06:50]** So I want to give everyone a minute here to just explore this scene.

**[01:06:50 – 01:06:53]** These 10 different environments with slightly different in terms

**[01:06:53 – 01:06:57]** of objects running in parallel, all evaluating the same policy.

**[01:06:57 – 01:06:59]** And at the end of this evaluation run, you're going to get

**[01:07:00 – 01:07:01]** metrics for basically all those environments.

**[01:07:02 – 01:07:05]** So it's way more testing that you've done, but kind of in

**[01:07:05 – 01:07:06]** very less time, right?

**[01:07:06 – 01:07:08]** Instead of doing that one environment like 10

**[01:07:08 – 01:07:10]** times sequentially.

**[01:07:10 – 01:07:13]** And that's really the value prop of using Isaac Lab Arena,

**[01:07:13 – 01:07:17]** that you can do this sort of parallel evaluation where multiple

**[01:07:17 – 01:07:19]** environments are running slightly different, you know, randomized

**[01:07:19 – 01:07:22]** object positions, randomized robot positions, but evaluating

**[01:07:22 – 01:07:24]** at the same time in parallel.

**[01:07:24 – 01:07:27]** And the reason this is really, really helpful, I think that

**[01:07:27 – 01:07:28]** it's very intuitive.

**[01:07:28 – 01:07:30]** The fact is that for evaluation, you need high diversity.

**[01:07:30 – 01:07:33]** Like, you cannot just evaluate on maybe three scenes and

**[01:07:33 – 01:07:35]** be reasonably sure that your policy performs.

**[01:07:35 – 01:07:37]** That's not a good way to do it.

**[01:07:37 – 01:07:40]** So as the number of objects grows, as the number of

**[01:07:40 – 01:07:43]** different positions or more randomization grows, evaluation

**[01:07:44 – 01:07:45]** takes that much more time.

**[01:07:45 – 01:07:49]** So to be able to do it in parallel like this really cuts down

**[01:07:49 – 01:07:54]** your evaluation time, honestly, from days to, like, hours.

**[01:07:54 – 01:07:56]** So feel free to keep running this and exploring this

**[01:07:56 – 01:07:58]** scene a little bit.

**[01:07:58 – 01:08:00]** I'm just going to go back to my slides and talk a little bit

**[01:08:00 – 01:08:02]** more about this evaluation process.

**[01:08:03 – 01:08:05]** But I see most of you have already started running the

**[01:08:05 – 01:08:06]** script, so that's great.

**[01:08:06 – 01:08:08]** And we'll come back to it once evaluation is done and

**[01:08:08 – 01:08:11]** see what our metrics look like.

**[01:08:14 – 01:08:16]** Okay, cool. So we looked a little bit at single

**[01:08:16 – 01:08:18]** environment evaluation.

**[01:08:18 – 01:08:19]** The YAML file here is important.

**[01:08:19 – 01:08:22]** You basically have to specify the model that you want to

**[01:08:22 – 01:08:26]** run, the policy, as well as a basic natural language instruction.

**[01:08:26 – 01:08:29]** Place the ranch bottle on the shelf on the fridge, something like that.

**[01:08:29 – 01:08:32]** And of course, all these files, these configs, they

**[01:08:32 – 01:08:33]** are on the GitHub.

**[01:08:33 – 01:08:35]** So whenever you run from the Isaac Lab Arena GitHub or

**[01:08:35 – 01:08:39]** from our documentation, you should be able to modify the file as well.

**[01:08:40 – 01:08:43]** We looked at homogeneous parallel environment evaluation, which

**[01:08:43 – 01:08:46]** is, again, parallel but running the same object with minor

**[01:08:46 – 01:08:49]** randomization in terms of robot position and object

**[01:08:49 – 01:08:51]** initial position.

**[01:08:51 – 01:08:54]** And we're actually running right now the multi-object example,

**[01:08:54 – 01:08:58]** where in addition to the robot and object position, we're changing

**[01:08:58 – 01:08:59]** objects of interest as well.

**[01:08:59 – 01:09:02]** So this is great for evaluating different policies zero-shot

**[01:09:02 – 01:09:04]** on other objects.

**[01:09:04 – 01:09:06]** And of course, I spoke a little bit about like, when you have

**[01:09:06 – 01:09:09]** so many axes of variation, you want to change object,

**[01:09:09 – 01:09:12]** you want to change physical properties, initial positions, then

**[01:09:12 – 01:09:16]** that's where the value of parallel evaluation really shines through.

**[01:09:17 – 01:09:18]** Finally, there's one more feature that you can try,

**[01:09:18 – 01:09:22]** it's called batch evaluation and it's just a more efficient way

**[01:09:22 – 01:09:24]** to run multiple evaluation jobs.

**[01:09:24 – 01:09:27]** So instead of manually having me as an operator come and launch

**[01:09:27 – 01:09:32]** different files, I can specify that entire YAML or in a JSON format

**[01:09:32 – 01:09:35]** and basically run that and have it give me like compute metrics

**[01:09:35 – 01:09:37]** at the end, so it will basically

**[01:09:37 – 01:09:40]** And it can also be across different task types.

**[01:09:40 – 01:09:42]** That's the interesting part. So here I have an example

**[01:09:42 – 01:09:45]** for not only the fridge place object and closed door, but

**[01:09:45 – 01:09:47]** also the microwave open door.

**[01:09:47 – 01:09:49]** So you can really mix and match the environment and

**[01:09:49 – 01:09:53]** the objects in the environment as well, but get evaluation metrics

**[01:09:53 – 01:09:55]** for all of that at the end of it.

**[01:09:56 – 01:09:57]** Now some benchmarks.

**[01:09:57 – 01:09:59]** This is interesting. One of our partners, Lightwheel, we

**[01:09:59 – 01:10:04]** did some experiments with them on an NVIDIA RTX GPU and we found that

**[01:10:04 – 01:10:07]** the GROOT policy that Edith briefly talked about, the VLA, that was

**[01:10:07 – 01:10:09]** evaluated on 10 Long Horizon tasks.

**[01:10:09 – 01:10:12]** So Long Horizon tasks are kind of like what we're running today.

**[01:10:12 – 01:10:14]** Very complex tasks with multiple steps.

**[01:10:14 – 01:10:17]** And you can see in the graph that we were able to scale

**[01:10:17 – 01:10:18]** up to that number of environments.

**[01:10:18 – 01:10:21]** So that's a huge, like 4096 environments.

**[01:10:21 – 01:10:22]** You can see the speedup is crazy.

**[01:10:22 – 01:10:25]** It's like a 13-time speedup in evaluation.

**[01:10:25 – 01:10:28]** So this is just an example of the community using it and it's

**[01:10:28 – 01:10:32]** kind of, it confirms that, yes, evaluation when done in parallel

**[01:10:32 – 01:10:35]** can have this kind of a speed up.

**[01:10:36 – 01:10:40]** So yeah, let me go back, actually, and check if our

**[01:10:40 – 01:10:42]** evaluation is done.

**[01:10:42 – 01:10:45]** Yes, it is. So in our terminal, you get the metrics that we

**[01:10:45 – 01:10:47]** discussed already.

**[01:10:47 – 01:10:51]** Subtask success rate is 0.95 for both the different subtasks we saw.

**[01:10:51 – 01:10:53]** And this is extensible, right? You could define any of your

**[01:10:53 – 01:10:56]** own subtasks as well.

**[01:10:57 – 01:10:58]** So, a quick review.

**[01:10:58 – 01:11:03]** We spoke about some metrics and how you can define granular metrics.

**[01:11:03 – 01:11:05]** We looked at the different modes, so like single environment,

**[01:11:05 – 01:11:08]** parallel, multi-object, and how to do batch evaluation.

**[01:11:08 – 01:11:11]** And we saw some benchmarks about how parallel environments

**[01:11:11 – 01:11:13]** really speed up evaluation.

**[01:11:13 – 01:11:14]** Quick review.

**[01:11:14 – 01:11:17]** This is a lot of the things we've covered so far in the lab.

**[01:11:17 – 01:11:20]** This section was mainly about granular diagnostics, large-scale

**[01:11:20 – 01:11:21]** parallel evaluation.

**[01:11:21 – 01:11:23]** And very quick, I'm going to talk about the next two,

**[01:11:23 – 01:11:27]** which is industrial benchmarks and how you can deploy this anywhere.

**[01:11:27 – 01:11:30]** So we have some partners and some ecosystem, we are trying

**[01:11:30 – 01:11:32]** to make this a project, of course it's open source, we want people

**[01:11:32 – 01:11:35]** to contribute, but we have some industrial and academic benchmarks

**[01:11:35 – 01:11:38]** already, everyone's using the same code base, so that's the advantage

**[01:11:38 – 01:11:40]** here, and you can actually share all of these for different tasks,

**[01:11:41 – 01:11:44]** so whether it's manipulation, local manipulation, locomotion,

**[01:11:44 – 01:11:48]** all of the, and if you scan this QR code below, this is the ecosystem

**[01:11:48 – 01:11:51]** of all the Isaac Lab Arena benchmarks that we're running.

**[01:11:51 – 01:11:53]** So some of our industrial benchmarks and academic that you

**[01:11:53 – 01:11:57]** see over here, again, the advantage and the vision here is having

**[01:11:57 – 01:12:01]** that sort of community shared assets as well as benchmarks.

**[01:12:01 – 01:12:04]** And finally, the convenience of deploying anywhere.

**[01:12:04 – 01:12:06]** It can be on your local workstation, which is kind

**[01:12:06 – 01:12:07]** of what we're doing now.

**[01:12:07 – 01:12:10]** It can be on a cloud native orchestration platform, or we have

**[01:12:10 – 01:12:13]** environment hubs and leaderboards that we support as well.

**[01:12:13 – 01:12:15]** And this is, again, the community point of view.

**[01:12:15 – 01:12:17]** We want people to be able to share and upload to all these

**[01:12:18 – 01:12:21]** different environments and hubs.

**[01:12:21 – 01:12:23]** So a quick example we have on Hugging Face is the code

**[01:12:23 – 01:12:24]** that you see here.

**[01:12:24 – 01:12:27]** So you really just have to run this within your LeRobot

**[01:12:27 – 01:12:31]** environment, and it's able to do evaluation on the small VLA policy.

**[01:12:31 – 01:12:34]** So we're just trying to make it easier to get started.

**[01:12:34 – 01:12:36]** And finally, we have some ready-to-use assets

**[01:12:36 – 01:12:37]** from the community.

**[01:12:37 – 01:12:39]** It's as easy as creating an environment, uploading it

**[01:12:39 – 01:12:42]** to Hugging Face, and anyone can download it from there.

**[01:12:42 – 01:12:45]** And some examples of data sets we have are these, like,

**[01:12:45 – 01:12:48]** ego point of view of a humanoid robot doing different tasks.

**[01:12:48 – 01:12:52]** You can find all of these on the NVIDIA Hugging Face.

**[01:12:52 – 01:12:55]** Cool, so to conclude, we'll have Sangeeta come up and

**[01:12:55 – 01:12:59]** do a quick wrap-up and some call to action, but essentially these are

**[01:12:59 – 01:13:00]** all the pieces that we saw today.

**[01:13:00 – 01:13:03]** We went from task curation, zero to one, to scaling the

**[01:13:03 – 01:13:08]** task, one to end tasks, granular diagnostics, and the rest

**[01:13:08 – 01:13:09]** of whatever you see here.

**[01:13:09 – 01:13:11]** And now we'll be talking very quickly about our call to

**[01:13:11 – 01:13:14]** action and how you can contribute.

**[01:13:15 – 01:13:18]** Thank you, Asad.

**[01:13:21 – 01:13:25]** Thank you everyone. I know it was lightning fast.

**[01:13:25 – 01:13:32]** We went over some concepts, but essentially, like everyone was

**[01:13:32 – 01:13:37]** saying, it's an open source project that it's in the alpha stages.

**[01:13:37 – 01:13:42]** A lot of the, we just made the 0.2 version available

**[01:13:42 – 01:13:44]** for developer preview on main.

**[01:13:44 – 01:13:46]** I'll share the link in just a bit.

**[01:13:46 – 01:13:49]** A lot of the features that you saw are available on

**[01:13:49 – 01:13:52]** main, are open source.

**[01:13:52 – 01:13:57]** We've got some work to do to get it stable on Isaac Lab 3.0 and Newton

**[01:13:57 – 01:13:59]** 1.0, which is just launching.

**[01:13:59 – 01:14:03]** That SQA process, all of that is coming together, and you'll

**[01:14:03 – 01:14:05]** have it in April real soon.

**[01:14:05 – 01:14:09]** But it's all there in Maine for you to check out, play with.

**[01:14:10 – 01:14:14]** We touched upon this briefly before the talk, where we're

**[01:14:14 – 01:14:18]** going next with this is, you saw how we have the blocks

**[01:14:18 – 01:14:25]** for sequential task training, relational object placement.

**[01:14:25 – 01:14:27]** That's the beginning.

**[01:14:27 – 01:14:31]** We were looking to expand that task setup further, like

**[01:14:31 – 01:14:34]** for example, your tasks need not be sequential, they can be

**[01:14:34 – 01:14:40]** Non-sequential but composite tasks built from atomic skills.

**[01:14:40 – 01:14:48]** And also we're looking to build upon the scene generation we have

**[01:14:48 – 01:14:53]** right now to make arena environment generation itself agentic.

**[01:14:53 – 01:14:56]** That is something that we're moving very fast towards in

**[01:14:56 – 01:14:57]** our next version.

**[01:14:57 – 01:14:59]** So hopefully the dream is that we'll be able to use

**[01:15:00 – 01:15:02]** natural language prompts and build towards this.

**[01:15:02 – 01:15:08]** environment and the variations that you need within another piece we

**[01:15:08 – 01:15:13]** we saw we had the the the low-level plugins for what can be what we

**[01:15:13 – 01:15:16]** call sensitivity analysis which is

**[01:15:16 – 01:15:19]** So I think the ultimate need to be able to really gauge your

**[01:15:19 – 01:15:22]** policy performance meaningfully so that you can iterate on

**[01:15:22 – 01:15:28]** it, which is being able to modify these parameters, micro isolated

**[01:15:28 – 01:15:34]** variations across parameters, across physics, structural,

**[01:15:34 – 01:15:38]** visual, kinematic parameters, and allowing you to just configure that

**[01:15:38 – 01:15:42]** without touching low level code, being able to sweep it and get

**[01:15:42 – 01:15:47]** Get that feedback in parallel heterogeneity is where I think

**[01:15:47 – 01:15:52]** we'll help you get that depth without compromising on time

**[01:15:52 – 01:15:53]** or hopefully faster.

**[01:15:53 – 01:16:00]** That's what we're working on, but we're early stage, so try it out.

**[01:16:00 – 01:16:03]** That's the 0.2 GitHub.

**[01:16:05 – 01:16:10]** We encourage you to, yes, snag a picture, try it out.

**[01:16:10 – 01:16:12]** We'd love feedback.

**[01:16:12 – 01:16:14]** Tell us what will help.

**[01:16:15 – 01:16:17]** The idea is it's

**[01:16:17 – 01:16:21]** As folks were saying, the idea is to build, as opposed to

**[01:16:21 – 01:16:24]** investing in individual scaffolds that only get us so much far,

**[01:16:25 – 01:16:29]** to build that one common core that we can all invest in and extend.

**[01:16:29 – 01:16:35]** We love GitHub issues, send us your bugs, features, suggestions.

**[01:16:35 – 01:16:41]** In the true spirit of open source, we welcome pull requests,

**[01:16:41 – 01:16:43]** proposed changes.

**[01:16:43 – 01:16:45]** Let's build this common core together.

**[01:16:45 – 01:16:49]** As you build your tasks, share them, distribute them with

**[01:16:49 – 01:16:51]** the community, share them on an environment hub or leader

**[01:16:51 – 01:16:55]** board like Hugging Face, or

**[01:16:56 – 01:17:00]** come let us know and we'll highlight it in the ecosystem

**[01:17:00 – 01:17:02]** list that we have as well.

**[01:17:02 – 01:17:07]** But yeah, hopefully with a bunch of these, we'll make dents in

**[01:17:08 – 01:17:16]** Making simulation-based evaluation and training, reduce the friction

**[01:17:16 – 01:17:22]** there and make it more a launchpad towards real-world performance

**[01:17:22 – 01:17:24]** and real-world capabilities.

**[01:17:24 – 01:17:28]** All right, that's all we had.

**[01:17:28 – 01:17:31]** Before I go into questions, just a few, we have some

**[01:17:31 – 01:17:32]** time for questions.

**[01:17:32 – 01:17:36]** Before that, just a few call to actions.

**[01:17:36 – 01:17:38]** Please, please tell us how you found the lab.

**[01:17:38 – 01:17:39]** Give us feedback.

**[01:17:40 – 01:17:41]** We're learning. We'll help make it better.

**[01:17:41 – 01:17:47]** It'll help just us make these courses more useful for you and

**[01:17:47 – 01:17:48]** make better use of your time, so.

**[01:17:48 – 01:17:49]** Please give us feedback.

**[01:17:50 – 01:17:51]** We'd love that.

**[01:17:51 – 01:17:55]** GTC is still very much on in full gusto.

**[01:17:55 – 01:17:58]** So if you're interested in the similar space, there's

**[01:17:58 – 01:18:02]** an Isaac Sim Lab, which is all about robot rigging and how you

**[01:18:02 – 01:18:06]** build and do software-in-the-loop testing with ROS 2.

**[01:18:06 – 01:18:08]** That's later today.

**[01:18:08 – 01:18:11]** And we have an amazing lab tomorrow morning with Isaac

**[01:18:11 – 01:18:17]** Lab 3.0 and Newton 1.0, which tells you all about how we're unlocking

**[01:18:17 – 01:18:24]** These perceptive workloads at scale and also Newton and

**[01:18:24 – 01:18:26]** all its cool features for high-fidelity contact physics.

**[01:18:26 – 01:18:29]** So all of that is coming.

**[01:18:29 – 01:18:33]** Come join us and please tell us how you liked it.

**[01:18:33 – 01:18:37]** That will help us make this better.

**[01:18:37 – 01:18:43]** And as a thank you for your time, hopefully you learned

**[01:18:43 – 01:18:45]** a bit about Isaac Laburina.

**[01:18:45 – 01:18:51]** What we have here is Brev is our platform for on-cloud,

**[01:18:51 – 01:18:55]** on-demand GPU access, so snack some credits and hopefully

**[01:18:55 – 01:18:58]** go have fun with some of the latest and greatest NVIDIA GPUs.

**[01:18:58 – 01:19:03]** Hopefully they'll make your simulation faster, we'll find out.

**[01:19:03 – 01:19:05]** And yeah, so with that, that's all I had.

**[01:19:05 – 01:19:08]** I'm going to pause here and open the floor to some, do

**[01:19:08 – 01:19:10]** we have some time for questions?

**[01:19:10 – 01:19:13]** Yeah, we have some time for questions.

**[01:19:13 – 01:19:15]** Did you want to, does, how did you want to do it?

**[01:19:15 – 01:19:18]** Does he get a mic?

**[01:19:19 – 01:19:25]** Here, why don't you pass this on, and the others will instruct us.

**[01:19:27 – 01:19:28]** It was a great presentation.

**[01:19:28 – 01:19:33]** I liked the relative on table with.

**[01:19:33 – 01:19:35]** Setting up a scene was always really a pain, but I have

**[01:19:35 – 01:19:40]** a question about with using the robot cameras, can you

**[01:19:40 – 01:19:43]** give us some advice on isolating the scenes so that one scene

**[01:19:43 – 01:19:47]** doesn't leak into another scene as you're training your environments?

**[01:19:47 – 01:19:51]** Like, so if you don't separate your environments enough,

**[01:19:51 – 01:19:58]** some other things can come into another robot's vision.

**[01:19:58 – 01:20:01]** Yes, absolutely. So for that, there is a parameter in the

**[01:20:01 – 01:20:04]** command, you'll see it, it says nspacing, so that's just

**[01:20:04 – 01:20:07]** a, like, you can specify a number, I think right now it's

**[01:20:07 – 01:20:10]** set at 0.8 or something, so it's spaced out, but you have to just

**[01:20:10 – 01:20:13]** make sure, at least visually, if you have that capability, to set it

**[01:20:13 – 01:20:16]** to something where it's not, like, where the robot's camera cannot see

**[01:20:16 – 01:20:19]** into another environment, so that parameter is one way to go about

**[01:20:19 – 01:20:25]** that, and then is there, are there more tricks for that, Alex, or?

**[01:20:25 – 01:20:28]** I mean, one trick is that you put a box around your scene, you

**[01:20:28 – 01:20:31]** know, you have an enclosed scene, so I think some people do that,

**[01:20:31 – 01:20:36]** but yeah, of course, in the ideal world, we'd be training policies

**[01:20:36 – 01:20:41]** that are sort of robust to, you know, variations in the visual

**[01:20:41 – 01:20:45]** appearance, so, you know, maybe seeing some different stuff moving

**[01:20:45 – 01:20:48]** in the background is maybe a good thing, I would say, but yeah, there

**[01:20:48 – 01:20:51]** are some tricks to get around that.

**[01:20:59 – 01:21:02]** Oh, to add something else on to that.

**[01:21:02 – 01:21:07]** Yeah, I will say for the camera, in Isaac Lab, there is also

**[01:21:07 – 01:21:11]** a parameter that you can set the cutoff range for the camera.

**[01:21:11 – 01:21:14]** So if you know you're positioning your environments, you know,

**[01:21:14 – 01:21:17]** X amount meters wide, then you can set that, and then

**[01:21:17 – 01:21:22]** you don't have to worry about other environments leaking in.

**[01:21:23 – 01:21:29]** So I really enjoyed the concept of object affordance and then

**[01:21:29 – 01:21:31]** combining it with object reference.

**[01:21:31 – 01:21:33]** The mixing pattern is pretty nice.

**[01:21:33 – 01:21:38]** The question is if you take someone like Lightwheel who

**[01:21:38 – 01:21:44]** has plenty of assets and you take the concept of affordance

**[01:21:45 – 01:21:51]** How could you process a large asset library quickly and add

**[01:21:51 – 01:21:56]** a simple affordance like open and close and then do you have plans

**[01:21:56 – 01:22:01]** to support multiple affordances per object if it has the ability to

**[01:22:01 – 01:22:07]** open and close and has buttons and can be turned and moved around, is

**[01:22:07 – 01:22:10]** that Get on the roadmap for Arena.

**[01:22:12 – 01:22:17]** So to the first question about how do you get affordances from

**[01:22:17 – 01:22:20]** USDs, I guess is what you're... So that's something we're thinking

**[01:22:20 – 01:22:23]** about, and in the future we'd like to move this definition of

**[01:22:23 – 01:22:30]** affordances into the USD schema so you get affordances with the asset.

**[01:22:30 – 01:22:32]** So that is something that we're thinking about, because at the

**[01:22:32 – 01:22:36]** moment you need to sort of manually wrap this USD in a piece of code

**[01:22:36 – 01:22:39]** which describes the affordances.

**[01:22:39 – 01:22:41]** And I guess what you're getting at is if you have

**[01:22:41 – 01:22:45]** lots of assets, that could be a time-consuming thing to do.

**[01:22:45 – 01:22:47]** So yeah, it's something worth thinking about.

**[01:22:47 – 01:22:50]** And we're also thinking about having multiple

**[01:22:50 – 01:22:55]** affordances per object.

**[01:22:55 – 01:23:03]** Say right now, that's possible, but maybe a bit awkward to do.

**[01:23:04 – 01:23:05]** We'd like to make that easier.

**[01:23:05 – 01:23:09]** Yeah, so basically, great questions.

**[01:23:09 – 01:23:12]** Things we're thinking about.

**[01:23:15 – 01:23:16]** Thanks for the great presentation.

**[01:23:16 – 01:23:22]** I just have a small question, for subtasks, how do you do contact

**[01:23:22 – 01:23:26]** modeling, do you have a contact sensor on the robot or you do like

**[01:23:26 – 01:23:30]** prim to prim contacts actually?

**[01:23:30 – 01:23:35]** So when you create these tasks, one of the things that it does is that

**[01:23:35 – 01:23:40]** when it builds the environment, it automatically adds contact sensors

**[01:23:40 – 01:23:43]** between task-relevant objects.

**[01:23:43 – 01:23:48]** So for example, it will add a contact sensor between, you

**[01:23:48 – 01:23:51]** know, say the apple and the bowl.

**[01:23:51 – 01:23:54]** You know, this is one of the great, great things about the framework,

**[01:23:54 – 01:23:57]** is that maybe if you did this in raw Isaac Lab, you'd have to

**[01:23:57 – 01:23:59]** manually add these contact sensing.

**[01:23:59 – 01:24:03]** This is all sort of handled behind the scenes.

**[01:24:07 – 01:24:10]** If anyone is still running the environments, of course

**[01:24:10 – 01:24:12]** you can feel free to keep experimenting a little.

**[01:24:12 – 01:24:15]** If you're running into issues, just put the red cup on top again,

**[01:24:15 – 01:24:16]** one of us can come and help you.

**[01:24:16 – 01:24:18]** We have a little more time in the lab, so you can keep

**[01:24:18 – 01:24:20]** experimenting a bit.

**[01:24:22 – 01:24:26]** Yeah, any other questions as well?

**[01:24:35 – 01:24:39]** I guess a question about Isaac Laberina.

**[01:24:39 – 01:24:41]** A little louder, sorry.

**[01:24:42 – 01:24:44]** Am I audible now?

**[01:24:44 – 01:24:46]** So a question about Isaac Laberina.

**[01:24:46 – 01:24:48]** You talked about one-to-one scaling.

**[01:24:48 – 01:24:51]** I'm curious if the scaling also applies to something

**[01:24:51 – 01:24:55]** like lightning conditions and friction of the floor.

**[01:24:55 – 01:24:59]** Can we make changes to those in Isaac Laberina already or is

**[01:24:59 – 01:25:03]** this something like for the future?

**[01:25:05 – 01:25:09]** Question was about low-level changes to individual parameters

**[01:25:09 – 01:25:10]** like friction or the lighting.

**[01:25:11 – 01:25:13]** Can we make changes to that?

**[01:25:14 – 01:25:18]** I think the simple answer is you can at a low level, like Isaac Lab

**[01:25:18 – 01:25:20]** itself naturally supports these.

**[01:25:20 – 01:25:22]** But one of the things that we were talking about in sensitivity

**[01:25:22 – 01:25:25]** analysis, which we're trying to do in the point three, is just make

**[01:25:25 – 01:25:30]** that configuration more easier for you guys, where you can configure

**[01:25:30 – 01:25:33]** Each of these changes, like lighting is a visual change

**[01:25:33 – 01:25:38]** or mass or friction or physics changes or kinematic changes,

**[01:25:38 – 01:25:44]** configure them more easily and then be able to run parallel sweeps

**[01:25:44 – 01:25:48]** across them so that you can see how your policy degrades with each

**[01:25:48 – 01:25:50]** of these micro isolated changes.

**[01:25:50 – 01:25:54]** So the short answer is you can do it at a low level, but we're

**[01:25:54 – 01:25:57]** trying to make it easier and just simpler for you to do it without

**[01:25:57 – 01:26:00]** having to touch low level code.

**[01:26:00 – 01:26:02]** Okay, thank you.

**[01:26:02 – 01:26:05]** Great session, thank you so much.

**[01:26:05 – 01:26:10]** One question is, you mentioned that you can do both reinforcement

**[01:26:10 – 01:26:12]** and imitation learning in this environment, of course.

**[01:26:12 – 01:26:15]** So what would be your recommended hardware for

**[01:26:15 – 01:26:17]** imitation learning using VR?

**[01:26:17 – 01:26:22]** For instance, the Quest or the Vision Pro or something else?

**[01:26:25 – 01:26:31]** So you mean the recommended VR hardware, well, hard to recommend

**[01:26:32 – 01:26:37]** between those options, but yeah, we support lots of different devices,

**[01:26:37 – 01:26:45]** the Quest and Apple Vision Pro are two examples, I mean, so this...

**[01:26:46 – 01:26:50]** Some things to consider, like the Apple Vision Pro doesn't

**[01:26:50 – 01:26:51]** have a controller, right?

**[01:26:51 – 01:26:55]** So you, for examples where you want to sort of move the,

**[01:26:55 – 01:26:59]** you know, the base of the robot,

**[01:26:59 – 01:27:00]** you need some way of doing that.

**[01:27:01 – 01:27:04]** And so maybe in that case, the Quest might be a better

**[01:27:04 – 01:27:06]** option because you have a joystick.

**[01:27:06 – 01:27:09]** But then that has the trade-off that your hand is sort of occupied,

**[01:27:09 – 01:27:13]** so you don't get finger tracking, so there are some trade-offs there,

**[01:27:13 – 01:27:17]** but we support a range of devices.

**[01:27:17 – 01:27:21]** I think, sorry to add on to that, I think as there's,

**[01:27:21 – 01:27:24]** we're starting to support more teleoperation devices,

**[01:27:24 – 01:27:27]** like if you're trying to go into locomotion as well, which is like

**[01:27:27 – 01:27:31]** another kind of paradigm instead of manipulation, there's, we have

**[01:27:31 – 01:27:36]** other devices like Pico that will allow you to kind of also walk and

**[01:27:36 – 01:27:40]** manipulate at the same time, yeah, so, because right now for the Apple

**[01:27:40 – 01:27:44]** Vision Pro, we're kind of, we have a CloudXR client which will track

**[01:27:44 – 01:27:45]** Like your hands and your arms.

**[01:27:45 – 01:27:49]** But once you kind of like get into other kind of paradigms,

**[01:27:49 – 01:27:52]** then yeah, you would, it all depends on kind of like what you're

**[01:27:52 – 01:27:55]** trying to do and what your goal is.

**[01:27:55 – 01:27:58]** Thank you. Okay, I think we probably have time for

**[01:27:58 – 01:27:59]** one more question.

**[01:27:59 – 01:28:02]** Does anyone have a question?

**[01:28:02 – 01:28:04]** Some of us will still be around here, so you can maybe meet

**[01:28:04 – 01:28:07]** us at the back or outside, and we can continue the great

**[01:28:07 – 01:28:08]** discussion there.

**[01:28:08 – 01:28:11]** But just wanted to thank everyone real quick for joining us today.

**[01:28:11 – 01:28:13]** Hope you learned something new, hope it was interesting,

**[01:28:13 – 01:28:16]** and you do have access to this course for six months.

**[01:28:16 – 01:28:18]** So you can actually, like, you do have these brief credits

**[01:28:18 – 01:28:20]** as well as the actual course that you are looking at right

**[01:28:20 – 01:28:21]** now from the DLI platform.

**[01:28:21 – 01:28:24]** You can access that later as well for up to six months.

**[01:28:24 – 01:28:27]** So thanks again, everyone, and have a great day.

**[01:28:27 – 01:28:27]** Thank you.