[CVPR'21 WAD] Keynote - Andrej Karpathy, Tesla

Yes, I'm very excited to be here. Thank you for the introduction. I would like to talk a bit more about what Tesla has been up to over the last few months. So first, to start, I guess we are here at the CVPR workshop on autonomous driving, so I think I'm preaching to the choir a little bit. But I'd like to start with some slides on, like, why we're doing all of this. And I think, unfortunately, we're kind of, like, in a bad shape when it comes to transportation in society. And basically the issue is that we have these metallic objects traveling incredibly quickly and with very high kinetic energy, and we are putting meat in the control loop, into the system. And so this is quite undesirable. And really fundamentally what it comes down to is people are not very good at driving. They get into a lot of trouble and accidents. They don't want to drive. And also in terms of economics, we are involving people in transportation. And of course we'd like to automate transportation and really reap the benefits of that automation in society. So we all, I think, are on the same page that it should be possible to replace the meat computer with a silicon computer and get a lot of benefits out of it in terms of safety and convenience and economics. So in particular, silicon computers have significantly lower latencies. They have 360-degree situational awareness. They are fully attentive and never check their Instagram and alleviate all of the issues that are presented. And so I think this is not super shocking, and a lot of people have been kind of really looking forward to this kind of a feature. This is a frame from I, Robot, a really good movie if you haven't seen it. And here Will Smith is about to drive a car manually, and this other person here is shocked that this is going to happen. This is ridiculous. Like, why would you actually have a human driving cars? And so I think this is not very far from truth, and this movie is taking place in 2035. So I think by then, I actually think this is a pretty present prediction. So what I think is kind of unique about Tesla and in our approach to autonomy is that we take a very incremental approach towards this problem. So in particular, we already have customers with the Autopilot package, and we have millions of cars, and the Autopilot software is always running and providing active safety features, and of course the Autopilot functionality. So we provide additional safety and convenience to our customers today, and also the team is working on full self-driving ability. So I would briefly like to very quickly speak to the value today that we provide, just to give you some examples of what the team is up to and what we're sort of doing today. So here's an automatic emergency braking scenario. So the driver here is proceeding through an intersection, and you can see trouble coming here. So the person kind of crept up from here, and the car sees the pedestrian, object detection kicks in, and we slam on the brakes, and we avert collision. Here's an example of a traffic control warning. So this person is probably not paying attention, potentially on the phone, is not braking for the traffic lights ahead, but we see that these are relevant traffic lights, they are red, and we beep, and the person immediately starts slowing and probably, you know, does not actually enter the intersection. These are examples from Pedal Misapplication Mitigation, PMM. Here, a person is unparking from their driving spot, and they are trying to turn, and then they mess up and they accidentally floor it. So they floor it right there, and the system kicks in. It sees pedestrians ahead of us, and it slams on the brakes and averts what would be a very gnarly situation in this case. Here's another last scenario I can show briefly. So this person is trying to park, and they turn to the right here, and they intend to press the brake, but they actually floor it. And the system again sees that there's no driving path forward and actually slams on the brakes and averts, you know, In this case, this person is not going to be swimming in this river imminently. So these are some examples of the value that we are providing today in this incremental autonomy fashion. But of course, the team is actually— Ladies, I thought tonight— Sorry about that. The team is working primarily on the FSD functionality, which is our full self-driving suite. So here we have about— we have the FSD beta product, and it's in the hands of about 2,000 customers. And this is an example from one of the customers driving around San Francisco. And these people are posting videos on YouTube, so you can check out a lot of videos. But we're showing here on the instrument cluster is we're showing all of our predictions. So you're seeing some road edges, some lines, some objects, and the car, of course, is navigating around autonomously here in San Francisco environment. Now, we, of course, drive this extensively as engineers. And so it's actually fairly routine for us to have zero-intervention drives, I would say, in like sparsely populated areas like Palo Alto and so on. I would say we definitely struggle a lot more in very adversarial environments like San Francisco. A lot of people working in autonomy, of course, know all about that as well. So this drive ends up being a fairly long drive, and it's zero interventions in this case. Now, one thing I like to point out always whenever I show the video of Tesla driving around autonomously in these city environments is you've seen this before, and you've seen it for a decade or more. So here's a Waymo taking a left at an intersection. And this is actually a pretty old video, I believe. And so you've been seeing stuff like this for a very long time. So what is the big deal? Why is this impressive? And so on. And I think the important thing to realize, and that I like to always stress, is that even though these two scenarios look the same, so there's a car taking a left at an intersection, under the hood, and in terms of the scalability of the system, things are incredibly different. So in particular, a lot of the competing approaches in the, in the industry take this LiDAR plus HD map approach. And so the idea is that you take an expensive sensor, LiDAR, on the top of the car, and it basically gives you range finding around the vehicle in 360 and gives you a point cloud. And what you have to do is you have to pre-map the environment with the LiDAR sensor, and you have to create a high-definition map, and then you have to insert all of the lanes and how they connect and all the traffic lights and where they are. And you basically have to create a high-definition map, and then at test time, you are simply localizing to that map to drive around. And so the approach we take is vision-based primarily. So everything that happens, happens for the first time there in the car based on the videos from the 8 cameras that surround the car. And so we come to an intersection for the very first time and we have to figure out where are the lanes, how do they connect, where are the traffic lights, which ones are relevant, what traffic lights control what lanes. Everything is happening at that time on that car and we don't have too much high-definition sort of information at all. And this is actually a significantly more scalable approach because if our product is on a scale of millions of customers on Earth, and so it's actually quite unscalable to, to actually collect, build, and maintain these high-definition LiDAR maps. It would be incredibly expensive to keep this infrastructure up to date. And so we take the vision-based approach, which of course is much more difficult because you actually have to get to get neural networks that function incredibly well based on the videos. But once you actually get that to work, it's a general vision system and can in principle be deployed anywhere on Earth. So that's really the problem that we are solving. Now, in terms of the cartoon diagram of a typical sensing suite of an autonomous vehicle, these are kind of like the typical sensors you would see. And as I mentioned, we do not use high-definition maps and we do not use LiDAR. We only use video cameras. And in fact, the, um, vision system that we have been building over the last few years has been getting so incredibly good that it's kind of leaving a lot of the other sensors in the dust. And so actually, the cameras are doing most of the heavy lifting in terms of the perception that you've seen in the car. And actually, it's gotten to the point that we are able to start removing some of the other sensors because they are just becoming these crutches that you start to not really need at all. So actually, 3 weeks ago, we started to ship cars that have no radar at all. So we've deleted the radar and we are driving on vision alone in these cars. And the reason we are doing this, I think, is well expressed by Elon in this tweet. He's saying, "When radar and vision disagree, which one do you believe? Vision has much more precision, so better to double down on vision than do sensor fusion." And what he's referring to is basically, like, vision is getting to the point where the sensor is like 100x better than, say, radar. Then if you have a sensor that is dominating the other sensor, and and so much better than the other sensor is actually starting to like really contribute. It's actually holding me back and it's really starting to contribute noise to the former system. And so we are really doubling down on the vision-only approach. And actually in this talk, what I would like to primarily talk about is how we have achieved vision-only control without radar and how we have released this quite successfully so far to the fleet and what it has sort of taken for us to do that. So here I wanted to show a video basically showing what the input to the system is. So we have 8 cameras surround, and these are fairly high-definition cameras, and we have 36 frames a second. And you can see that basically you can actually understand a lot about this environment from this input. It's extremely information-rich. You're getting a huge amount of constraints, 8 million bits roughly of constraints per second on the state of the surroundings. And so it's incredibly information-rich compared to any other sensor you may want to have in a car. And so this is the one that we're doubling down on because this is ultimately where all the difficult sort of scene interpretation challenges lie. So we prefer to just focus all of our infrastructure and development on this, and we're not wasting people working on the radar stack and the sensor fusion stack. We only have one team, the vision team. Now, typically when we talk about vision, the reason people are squeamish about using vision is, and the sort of challenge that almost always is pointed out, is people are not certain if neural networks are able to do range finding or depth estimation of these objects. So obviously humans drive around with vision, so obviously our neural net is able to process visual input to understand depth and velocity of all the objects around us. But the big question is, can our synthetic neural networks also do the same? And I think the answer to us internally over the last few months that we've worked on this is an unequivocal yes, and I'd like to sort of talk about that. So in particular, the Radar API or like what the radar really gives you, is it gives you a quite accurate depth and velocity measurement. It's a pretty direct measurement of the car ahead of you in very nominal situations. So here I'm showing a random image on the left, and you are seeing the depth, velocity, and acceleration reported by the radar stack for this car. And you can see that it's a bit wiggly on the velocity, so this is some kind of a stop-and-go scenario. Now, when radar has a good lock on the car in front of you, it's given incredibly good depth and velocity. But the problem with radar is like once in a while at random, it will give you a dumb measurement and you will not know when that is. And so it's incredibly hard to fuse with vision in our experience. So it might suddenly see a spurious stationary object because of a manhole or because of a bridge or crossing objects are not very well tracked or oncoming objects are not very well tracked. And it ends up contributing noise. I'll go into more detail in a bit. But for our purposes, what we want to do right now is we want to match the quality of these predictions using vision alone. So the question is, how can you get a neural net to predict depth, velocity, acceleration directly, and do it with a very high fidelity matching that of radar? So the approach we're going to take, of course, is we're going to treat this as a supervised learning problem, and we need a massive dataset of depth, velocity, acceleration on a lot of cars, and we're going to train a large enough neural network and do a very good job at that. That's the standard vanilla approach, and that actually works really well if you do it properly. So here's what it took. So the first component that you need is an incredibly good dataset. So, and when I talk about a good dataset, I believe it has to have 3 properties that are critical. It has to be large, in millions of examples. It needs to be clean. So in this case, we have to have a very clean source of depth, velocity, and acceleration for all these cars. And it must be diverse. So we're not just talking about a single, you know, driving clip of going forward on a highway. We really have to get into the edge cases and mine all the difficult scenarios. And I'm going to show you some examples. And when you have a large, clean, diverse dataset and you train a large enough neural network on it, what I've seen in practice is, in the words of Ilya Sutskever, success is guaranteed. And so let me show you some examples of that. So how are we going to— so first of all, how are we going to achieve this dataset? So of course, we need to collect training data. The typical approach might be to use humans to annotate cars around us in 3 dimensions. What we found actually works really well is an auto-labeling approach. So it's not pure humans, just like annotating cars. It's an offline tracker, as we call it, and it's an auto-labeling process for collecting data at the scale that is necessary. So we need, again, millions of hard examples. So this is where the scale comes from, is that it's not labeled purely by humans, although humans are involved. It's labeled automatically. So here's an example of some automatic labels we were able to derive for cars on the highway. And the way you do this is because you are offline and you are trying to just annotate a clip, you have a large number of benefits that you don't typically have if you're at test time under strict latency requirements in the car. So you can take your time to fully figure out exactly all the objects and where they are. You can use neural networks that are extremely heavy, that are not deployable for various reasons. You can use benefit of hindsight because you know the future, not just the past. You can use all kinds of expensive offline optimization and tracking techniques. You can use extra sensors. In this case, for example, actually radar was one of the sensors that we used for the auto-labeling. But there's actually a massive difference between using radar at test time and using it in the offline tracker. And that is that at test time, a radar can just report a stationary track immediately in front of you, and you have 20 milliseconds to decide if you're going to brake or not. If you're offline, you have the benefit of hindsight, and so you can do a much better job of calmly fusing if you really want to. And so there is a massive difference there. And in addition, you can of course involve humans and they can do cleaning, verification, editing, and so on. And so we basically found that this was a massive lever to allow us to reach the scale and the labeling quality. And then to get the diversity, that was also a massive fight. So here's some examples of really tricky scenarios. So here there's some, I don't actually know exactly what this is, but basically this car, drops a bunch of debris on us, and we maintain a consistent track for the label. And of course, if you have millions of labels like this, the neural net, if it's a powerful enough neural net, will actually end up learning to persist these tracks in these kinds of scenarios. Here's another example. There's a car in front of us, and I actually am not 100% sure what happens in this case, but as you'll see, there's some kind of a dust cloud that develops here and briefly occludes the car. But in the auto-labeling tool, we are able to persist this track because we saw it before and we saw it after. So we can actually stitch it up and use it as a training set for the neural net. Here's one more example of an adversarial scenario from heavy snow. Again, we can auto-label this fine and create a large collection of examples. Now, as we were working on this over a duration of, I want to say, of roughly 4 months of really just focusing a lot of the team on this problem of achieving really good depth velocity, and acceleration, we've ended up developing 221 triggers manually that we were using to source data from our customer fleet. And this is just an example, some examples of the 221 triggers that were used to collect all of these diverse scenarios. So for example, we have shadow mode where we deploy a neural network that is pretty good at predicting depth and velocity. And what we do is we run it silently in the cars of our customers, but it's not actually connected to control. What's driving is the legacy stack, but we're basically running the new measurements of depth and velocity, and we're, for example, looking at whether or not they agree or disagree with the legacy stack or with the radar. We're looking for other sources of jank, like for example, if there's bounding box jitter, detection jitter, the main and the narrow camera disagree, we predict that there's a harshly decelerating object but the person seems to not mind. All kinds of disagreements between different neural network signals. And, you know, there's a long list here. It took us a while to actually perfect these triggers, and all of them are iteration, and you're looking at what's coming back, you're tuning your trigger, and you're sourcing data from all these scenarios. So basically over the last 4 months, we've done quite extensive data engine. We've ended up doing 7 shadow modes and 7 loops around this data engine here. Where on the top right is where you begin. You have some seed dataset. You train your neural network on your dataset, and you deploy the neural network in the customer cars in shadow mode. And the network is silently making predictions. And then you have to have some mechanisms for sourcing inaccuracies of the neural net. So you're just looking at its predictions. And then you're using one of these triggers, like I described. You're getting these scenarios where the network is probably misbehaving. Some of those clips end up going to unit tests to make sure that we, even if we're failing right now, we make sure we pass later. And in addition, those examples are being auto-labeled and incorporated into a training set. And then as an asynchronous process, we're also always data cleaning the current training set. And so we spin this loop over and over again until the network basically becomes incredibly good. So in total, we've done 7 rounds of shadow mode for this release. We've accumulated 1 million extremely hard diverse clips. And these are videos. So these are— you should roughly think about, say, 10-second clips. 36 FPS, something like that. In total, we have about 6 billion objects labeled cleanly for depth and velocity. And this takes up roughly 1.5 petabytes of storage. So that gives us a really good dataset. Of course, that by itself does not suffice. So we have an incredibly good AI team that is designing the neural network architecture. That is basically the layout of the synthetic visual cortex in order to efficiently process this information. So our architecture roughly looks like this. We have these images coming from multiple cameras on the top. All of them are processed by an image extractor, like a backbone, like think ResNet kind of style. Then there's a multicam fusion that fuses the information from all the 8 views. And this is a kind of a transformer that we use to fuse this information. And then we fuse information first across all the cameras and then across all of time. And that is also done either by transformer, by recurrent neural network, or just by 3-dimensional convolutions. We've experimented with a lot of— kind of fusion strategies here to get this to work really well. And then what we have afterwards, after the fusion is done, is we have this branching structure that doesn't just consist of heads, but actually we've expanded this over the last few— last year or so, where you now have heads that branch into trunks that branch into terminals. So there's a lot of branching structure. And the reason you want this branching structure is because there's a huge amount of outputs that you're interested in, and you can't afford to have a single neural network for every one of the individual outputs. You have to, of course, amortize the forward pass for efficient inference at test time. And so there's a lot of feature sharing here. The other nice benefit of the branching structure is that it decouples— at the terminals, it decouples all these signals. So if I am someone working on velocity for a particular object type or something like that, I have a small piece of neural network that I can actually fine-tune without touching any of the other signals. And so I can work in isolation to some extent and actually get something to work pretty well. And then once in a while, so basically the iteration scheme is that a lot of people are fine-tuning and once in a while we do an uprev of all of the backbone end-to-end. And so it's a very interesting sort of mechanism because we have a team of roughly 20 people who are, I would say, training neural networks full-time and they're all cooperating on the single neural net. And so what is the workflow by which you do that is pretty fascinating and continues to be a challenge to actually design efficiently. So we have a neural network architecture, we have a dataset. Now training these neural networks, like I mentioned, this is a 1.5 petabyte dataset, requires a huge amount of compute. So I wanted to briefly give a plug to this insane supercomputer that we are building and using now. And, you know, for us, computer vision is the bread and butter of what we do and what enables the Autopilot. And for that to work really well, you need massive dataset. We get that from the fleet, but you also need to train massive neural nets and experiment a lot. So we've invested a lot into the compute. In this case, we have here a data center. We have a cluster that we're just building that is 720 nodes of ATAX A100s of the 80GB version. So this is a massive supercomputer. I actually believe that in terms of flops, this is roughly number 5 supercomputer in the world. So this is actually a fairly significant computer here. We have 10 petabytes of hot tier NVMe storage. And it's also an incredibly fast storage. So I believe at 1.6 terabytes per second, this is one of the world's fastest file systems. And we have a 60— we have also a very efficient fabric that connects all of this. Because of course, if you're doing distributed training across your nodes, you need your gradients to be synchronized very efficiently. And of course, we are reading all of these videos from the file system, and that requires really fat pipe as well. So this is a pretty incredible supercomputer. And so this is a GPU cluster. Next up, we're really hoping that— we're currently working on Project Dojo, which will take this to the next level. But I'm not ready to sort of reveal any more details about that at this point. What I would like to do is I would like to just briefly plug the supercomputing team. They've been growing a lot. And so if high-performance computing for this application and for training these crazy neural networks excites you, then we would definitely appreciate more help. So please contact the supercomputing team at Supercomputing@Tesla to help us build these clusters. On the left here, we have the compute nodes, and on the right, this is a network switch, actually. So the wires here is kind of like the white matter of this synthetic cortex, I guess. The other thing I wanted to briefly talk about is I wanted to also mention briefly that this effort basically is incredibly vertically integrated. In the AI team. So as I showed you, we own the vehicle and the sensing, and we source our own data, and we annotate our own data, and we train our on-prem cluster, and then we deploy all of the neural networks that we train on our in-house developed chip. So we have the FSD computer here that has two SoCs, FSD chips here, and they have our own custom NPU, neural processing unit, here at roughly 36 TOPS each. And so these chips are specifically designed for the neural networks that we want to run for FSD applications. And so everything is very vertically integrated in the team. And I think that's pretty incredible because you get to really co-design and engineer at all the layers of that stack. And there's no third party that is holding you back. You're fully in charge of your own destiny, which I think is incredibly unique and very exciting. And then we have a deployment pipeline here where we take these neural networks and we do a lot of typical graph optimization, fusion, quantization, threshold calibration, and so on. And deploy it on our chip. And this is in the customer's cars and these neural networks run there. So now what I'd like to show is, I first would like to show some qualitative examples of some of our results in terms of the depth and velocity predictions that we were able to achieve by putting all of these pieces together and training these networks at scale. So the first example here, I have a video where this is on track testing. So this is an engineering car and we asked it to slam on the brakes as hard as it possibly can. So this is a very harsh braking here in front of us, even though it doesn't look like that in the video, this is very harsh braking. So what you can see on the right here is you can see the outputs from the legacy stack, which had Radar Vision Fusion, and from the new stack, which is vision alone in blue. So in the orange legacy stack, you can actually see these track drops here when the car was braking really harshly. And basically the issue is that the braking was so harsh that the radar stack that we have actually ended up not associating the car and dropping the track and then reinitializing it all the time. And so it's as if the vehicle disappeared and reappeared like 6 times during the period of this braking. And so this created a bunch of artifacts here, but we see that the new stack in blue is actually not subject to this behavior at all. It just gives a clean signal. In fact, here there's no smoothing, I believe, on the blue signal here. This is the raw depth and velocity that comes out from the neural net, the final neural net. That we released with about 3 weeks ago. And you can see there, it's fairly smooth here. And of course you could go into the radar stack and you could adjust the hyperparameters of the tracker, like why is it dropping tracks and so on. But then you are spending engineering efforts and focus on a stack that is like not really barking up the right tree. And so it's better to, again, just focus on the vision and make it work really well. And we see that it is much more robust when you train it at scale than something like this. Here's another example, fairly infamous example of slowdowns when there are cars going below a bridge. The issue here again is that the radar does not have too much vertical resolution. So radar reports a stationary object in front of you. It's as if like the radar doesn't know that there's, if it's, there's like a stationary car in front of you or if it's the bridge above. It cannot differentiate those two. So radar thinks that there might be something stationary in front, And it's just like looking for something in vision to tell it that it might be correct. And then we create a stationary target and brake. And so in this case, in the legacy vision predictions, which were already producing depth and velocity, but because we were using radar, the vision inaccuracies were being masked because your bar is only at radar association. Your bar is not at actual driving. And so the depth and velocity were not held up to a high enough bar. And so basically what happens is vision reports a slightly— for a few frames, reports a slightly too negative velocity for the car, and then it associates to the stationary object, and the stack is like, oh, that must be the stationary thing, and then we brake. And so this, of course, is much cleaner, and you see that the new stack does not see this at all, and there's no track— there's no slowdowns in this case, because we just get the correct depth and velocity, and vision obviously has the vertical resolution to differentiate a bridge from a car and whether or not the car is slowing or not. So again, you could go into the vision step, the radar stack, or the sensor fusion stack, and if you have an improved depth and velocity, you could change the fusion strategy. But again, you're just kind of like doing dead work. Like, this signal is so good by itself, why would you, why would you do that? So in this, in this setting, now we've, we've improved the situation quite a lot. Here's another last example. We have a stationary approach. Again, this is in track testing environment. This is an example of a test that we would run. and we are just approaching this vehicle and hoping to stop. What you see in orange in the legacy stack is that it actually takes us quite a bit of time for us to start slowing. And basically what's happening here is that the radar is very trigger-happy and it sees all these false stationary objects everywhere. Like everything that like sticks out is a stationary target and radar by itself doesn't know what actually is a stationary car and what isn't. So it's waiting for vision to associate with it. And vision, if it's not held up to a high enough bar, is noisy and contributes sort of error, and the sensor fusion stack just kind of like picks it up too late. And so again, you could fix all that, even though it's a very gross system with a lot of if statements and so on, because the sensor fusion is complicated because the error modes for vision and radar are slightly— are quite different. But here, when we just work with vision alone and we take out the radar, vision recognizes this object very early, gives the correct depth and velocity, and there's no issues. So we actually get an initial slowdown much earlier. And we've really simplified the stack a lot as well. So just speaking very briefly to the release and validation, we've extensively validated this before we, of course, ship this to customers. Just some example numbers for the validation itself. We've handpicked about 6,000 clips in about 70 categories of scenarios like harsh braking, crossing vehicles, different vehicle types, environments, and so on. And we run these tests on all the commits of the build, and we run them also every day periodically as we were trying to drive up the performance on these clips. We also use simulation extensively for validation. We've also used simulation for training, although I haven't gone into that, but we've had some successes there. But we use it primarily for validation at this stage, and that's again like diversity of scenarios, trying to make sure that the stack is performing correctly. We've done a lot of track testing, and I've shown you some examples of that. We've driven this extensively in the QA fleet, and we've also deployed this in shadow modes and seen that this stack performs fairly well. So in particular, for example, for the automatic emergency braking, we actually see a higher precision and recall compared to the legacy stack, that is, the Fusion stack. And so having seen all this, we've actually released this. We've accumulated about 15 million miles so far, and 1.7 million of those have been on Autopilot, and so far there have been no crashes. Now, of course, we're running at massive scale here, and so we do expect some crashes at some point. The legacy stack has a crash roughly every 5 million miles or so, I believe. And so we do expect some, some incidents at some point, but this— the improvements for the Vision stack are not sort of stopping. So I think we're very confident that we're barking up the right tree here and that we can actually get this to work really incredibly well. Um, I also want to briefly give a shout out to auto-labeling as an incredibly powerful method for sourcing training data. So we're applying auto-labeling to all of the FSD tasks, not just the depth and velocity of the car in front of us. Here's an auto-labeler for pedestrians, um, and, uh, you can see that the tracks are very smooth. And this is again a completely offline process that we are applying not just to objects but also to a lot of static environments. So this is some example of a 3D reconstruction. So here we see a clip, and this is a vision-only estimate of the depths of all the points. And of course, you don't actually want to really deploy these measurements directly into a car because they are too raw. So what you actually want to do is you want to, again, auto-label. And you want to really think about, what is it— what is the information I really need at test time in the car? And what is, like, as close as possible to action? So you want to do all this work at training time, figure out exactly what happened in the clip, reconstruct the entire environment, and then you want to actually like post-process the curb at training time. So you want to do as much at training time and labeling time as possible. And then you want to figure out what are the tasks I really need at test time. And that's the thing that happens in the car, subject to very strict latency requirements. You want to do as little post-processing there as possible. So we see that this is a very powerful lever on creating datasets. So in summary, what I try to argue and give you a sense of is vision alone is actually— in our— is our finding that this is perfectly capable of depth sensing. It is an incredibly rich sensor in terms of bandwidth of information, and doing this and matching radar performance and depth and velocity is incredibly hard. I believe it requires the fleet because the dataset that we were able to achieve was critical in all these performance improvements. And if you do not have the fleet, I'm not 100% sure how you can source all the difficult and diverse scenarios that we did source. Because I believe that was critical to getting this to work. So it's hard, requires massive networks, a supercomputer, and data engine, and the fleet. But all of these components are coming together in a vertically integrated fashion at Tesla AI. And I believe that this makes us sort of uniquely positioned in the industry. Where we are barking up the right tree and we have all the puzzle pieces to make this work. And so if you are excited about this approach that we're taking and the networks and the work that we're doing, then I would encourage you to please apply and join the team and help us make this a reality. So you can go to tesla.com/autopilotai. It's a very simple process. You upload a resume and you have a blurb about some of the things that you've done that are impressive. And then that comes directly to us. And we'd love to work with you to make this a reality. Thank you.