Qwen-Drive-1.0-4B: Why You Still Can't Trust AI with Self-Driving Cars: Hands-on

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: Qwen-Drive-1.0-4B: Why You Still Can’t Trust AI with Self-Driving Cars: Hands-on · Channel: Fahd Mirza · 08:46 · Watch on YouTube

Topics: Software engineering with AI, Multimodal models, Robotics and autonomous systems, AI safety

Summary

The video introduces Qwen-Drive-1.0, which builds driving perception and planning modules around a vision-language model so it can interpret road scenes and explain proposed actions. The presenter describes its benchmark results, closed-loop simulation tests, and straightforward repository setup, then demonstrates it on real driving footage. In the demo, the model accurately describes several details but contradicts itself when planning, recommending acceleration through a green light despite the light being red. The presenter concludes that the model is promising but still makes mistakes and cannot yet be trusted to drive autonomously.

Key points

Qwen-Drive-1.0 aims to combine scene understanding and driving decisions in one model rather than relying entirely on separate systems.
The project starts from the Qwen 3.5 4B vision-language model and adds perception and planning modules.
The perception head converts multi-view camera images into a bird’s-eye view and identifies road users, obstacles, drivable areas, sidewalks, and lane lines.
The planner predicts a five-second trajectory and can provide a natural-language explanation for its intended action.
The presenter says the model performs strongly on driving question-answering and scene-understanding benchmarks while retaining general image capabilities.
The release includes two planner versions: one trained by imitation and another further trained with reinforcement learning for human preferences and safety in closed-loop simulation.
The model is demonstrated on a driving scene using 12 camera frames from three angles; the presenter reports memory usage of around 12 GB.
In the demo, the model describes the scene well but gives an unsafe, contradictory trajectory instruction by treating a red light as green.
The presenter argues that the demonstrated error is a reminder that AI driving systems are not yet trustworthy enough for self-driving cars.

Chapters

Start	Chapter	Summary
00:01	The gap between seeing and understanding	The presenter frames the limits of conventional self-driving systems and introduces Qwen-Drive as an attempt to combine visual understanding with driving.
01:11	Qwen-Drive’s perception and planning modules	The video explains the model’s added bird’s-eye-view perception head and its planner, which predicts trajectories and explains actions in language.
03:24	Benchmarks, closed-loop tests, and release setup	The presenter discusses benchmark performance, planner training approaches, closed-loop simulation, and the project’s repository structure.
06:03	Hands-on demo and a critical planning error	The presenter runs the model on real driving footage, shows its memory use, and highlights its incorrect instruction to accelerate at a red light.

Quotes

But looking isn’t the same as understanding. — 00:01

It reasons first decelerate to yield to the fox crossing the road ahead. — 02:53

you are loading a model that can watch a driving scene, either describe it, detect what’s in it, or decide what to do about it. — 06:03

accelerate through a green light even though the light is red. — 08:14

you can’t really trust um AI with self-driving cars at the moment. — 08:14

Concepts and entities

Qwen-Drive-1.0-4B, Qwen, Tesla, Fahd Mirza, Hugging Face, NAVSIM, perception head, planner, closed-loop simulation, reinforcement learning

Full transcript (original language)

00:01 If you minus Elon Musk’s rubbish marketing of his Tesla, there’s a strange irony sitting at the heart of every self-driving car project. The camera on the roof of that vehicle can see a pedestrian, a stop sign, a dog running across the road. But looking isn’t the same as understanding. For years and years, the industry has built these cars out of separate brains bolted together. One brain detects objects. Another draws a map. A third one decides

00:37 what to do next. And none of them can actually explain what they just watched or why they made a choice. Ask the car why it slowed down and it has nothing to say. It just slowed down. This is Fad Miraza and I welcome you to the channel. This video is not a bashing of Tesla or anything. I actually like Tesla a lot. What I don’t like is brainless marketing, especially from its founder. Anyway, I digress. So, look, this is the problem this new project is trying to

01:11 solve. Quen decided to go after with Quen Drive 1.0 zero and their answer is almost deceptively simple. What if the same model that can look at a photo and describe it in plain English is also the model doing the driving not a separate system stitched on afterwards the same brain doing both the starting point is this coin 3.54 billion which let me show you is available on hugging face at the

01:45 moment which is quite cool. So if you look at this, this is a vision language model that already understands images and text together. The Quen team didn’t touch its architecture. They didn’t rebuild it, retrain its core, or bolted on some exotic new structure. They kept it exactly as it was and then attached two new new modules to it that share its understanding of the world. The first module is a perception head. It takes the multi- view camera images

02:19 from the car and produces a bird’s eye view of the scene. It detects vehicles, pedestrians, cyclists, cones, barriers. It estimates what’s drivable, what’s the sidewalk, where the lane lines are. But here, I think what really really is cool is that this module was deliberately kept simple. The Quen team wasn’t trying to build the most advanced perception system on the planet. They wanted an honest window into what the language model itself understood about 3D space,

02:53 a way of checking its work. The second module is the planner. And this is where things get really interesting. As you can see, it looks at the road ahead and predicts the 5-second trajectory, the actual path the car should take. But it doesn’t just spit out coordinates. It reasons first decelerate to yield to the fox crossing the road ahead. As you can see on your screen, nudge left to pass the stopped utility truck while maintaining speed.

03:24 The car explains itself in a sentence and then it acts on that sentence. Hopefully, it won’t really start reasoning like when 3.8 otherwise, you know, fox will be hit and we’ll be um long past anyway. So, how well does it actually work on driving specific question answering benchmarks? Quen drive 1 doesn’t just edge out the competition. It separates itself from it compared to general purpose vision models and specialized driving alike. It

03:56 scores highest on almost every measure of scene understanding, safety reasoning, and spatial awareness. And what’s notable is that this jump didn’t come at a cost. The model didn’t forget how to do everything else it used to do. Feed it a totally unrelated image, a math diagram, a chart, a photo with no cars in it at all and it performed essentially the same as it did before any of this driving specific training happened which is quite interesting.

04:27 Then there is the part that actually um I felt is quite um salient in this one which is what happens when the car has to drive not just described in closed loop simulation where the model’s own decision change you know decisions change what happens next moment by moment the planner has to stop at red lights accelerate through green ones yield to pedestrians and adjust its path in real time as the world reacts to it. You can see it in these trajectory maps.

05:01 Multiple possible paths get considered and the model settles on the one that actually respects the rule of the road. Two versions of the planner were released. One trained through straightforward imitation of human driving. The other pushed further with reinforcement learning rewarded specifically for matching human preferences and for staying safe in closed loop simulation. And that second version is the one that pulls ahead on almost every serious planning benchmark from NAVSIM to the VHO end to end

05:33 challenge. What’s refreshing here is how unpretentious the release itself is. It’s one repository. That’s it. And they also have shared a quick start as you can see on your screen. The core language model sits at the root. The planning expert and the perception head each live in their own small folder. right next to it. No sprawling ecosystem, no 15 different repos to hunt down. You clone it, you download the weights and within a few lines of code,

06:03 you are loading a model that can watch a driving scene, either describe it, detect what’s in it, or decide what to do about it. How good is that? I’m also going to do a demo shortly, so don’t worry. This is a hands-on video but I really wanted to make this whole spiel so that you would know what exactly is happening um because this is the real story here. So let me quickly take you uh to my terminal and I will quickly show you. So I’m just downloading the model as you can see coin drive.

06:36 Let me quickly show you. Sorry. There you go. The model is downloaded. Now I’m going to run this demo script pointing it at a real driving scene and ask it to describe what’s happening and predict where the car should go. This is actual scene as you can see um 12 real camera frames and from three different angles around the car. I’m just skipping you know skimming through different you know sort of scenes which they have provided in their repo which you can also download

07:09 from hugging face. I will drop the link in video’s description. This is just captured before this moment. And also this is a file that stitches those frames together with their camera angle and time step JSON L file. So the model knows what it’s looking at and when. So let me quickly sorry let me quickly run this. It is going to load the model and then we will check out the VM consumption too. You can ignore the warnings.

07:40 The weights have been loaded. Let me show you the VMA consumption. It is going to jump up. There you go. The 4 billion parameter model. And I think it just goes around 12 gig or something. There you go. So, it’s stabilized. And our model is still running. Let’s wait for it to come back. So, this is the output of the model. When I asked it to just describe the scene, it has really thrown it out of the park. It says wet road, red light,

08:14 uh, right turn only lane and it correctly said the stopped. But when I asked it to actually plan a trajectory, it flipped its own answer and said accelerate through a green light even though the light is red. And the numbers back up back that up go to. So, all in all, good. But remember, these models can still make mistakes. And that is what my whole point is that you can’t really trust um AI with self-driving cars at the moment. I know this is not a popular opinion, but I’m just cutting out the hype and this is where the

08:46 things stand at the moment. That’s it. Let me know what do you think. Again, if you want to help out the channel, just become a member. Thank you for all the