Janelle Is Training An Ai Powered Model Car

Why Model Car Racing Keeps Dragging Me Into Neural Networks

I was running a weekend club meet at the local outdoor track when someone rolled up with a 1/10th scale touring car that wasn't using the usual ESC or receiver layout. Instead there was a small compute board bolted near the center of gravity, camera feed going back to a laptop on a support cart, and the car was making steering decisions in real time. That was the moment I realized the hobby had quietly split into two separate worlds. The short version of what Janelle is doing has been making rounds in a few technical circles. She is training a neural network to drive a physical model car by collecting telemetry and video from the vehicle, generating labeled driving data through simulation and on-track runs, and then fine-tuning a policy network that controls steering, throttle, and braking. The result is not just a remote-control car with fancy sensors. It is a closed-loop system where the car decides when to turn, how late to brake, and whether to take a high or low racing line based on what its camera sees. I have spent years building telemetry systems for RC vehicles, so I did not immediately trust the first demo video. The car looked smooth, but it also had a habit of correcting too late on exit curves and briefly oversteering through chicanes. That pattern told me the training data probably overrepresented high-speed sweepers and underrepresented tight transitions. I reached out to people working on similar builds and confirmed that behavior is common when the reward signal focuses too heavily on lap time without penalizing directional instability.

How The Training Pipeline Actually Works

Most of these projects follow the same backbone, even if the hardware changes from week to week. The process starts with a simulator because real tracks eat batteries and bent suspension arms. People use environments that mimic their car's mass properties, tire grip curves, and camera distortion. The simulator generates thousands of laps while the agent learns by trial and error. Then the model gets moved to the real car for domain adaptation, usually through techniques like domain randomization or fine-tuning on a small set of recorded laps. What separates the builds that actually drive from the ones that crash within thirty seconds is data quality and reward design. A naive reward function will push the car to drive faster by taking increasingly risky lines until it spins out on a damp patch. A better reward function layers in penalties for excessive steering rate, wheel slip, and deviation from a reference racing line, while rewarding smooth progression through sector checkpoints. Janelle's approach appears to use something close to this layered structure, which is why the car stays on track long enough to look competitive rather than just fast in a straight line. The perception side typically relies on a single forward-facing camera with a lightweight convolutional network or a vision transformer adapted for embedded inference. The model maps image patches to control commands, sometimes after projecting the image into a bird's-eye view to make spatial reasoning easier. Latency matters a lot here. If the inference loop takes longer than 80 milliseconds, the car will already be past the point where steering input can prevent a cornering mistake. Most successful builds run inference at around 30 to 50 milliseconds on hardware like a Jetson Orin Nano or a similarly sized accelerator.

What I Learned After Watching A Full Session Run

I got my hands on a similar setup last spring and tried to reproduce the kind of consistency people were showing online. The first problem I ran into was not the model. It was the power delivery under load. When the compute board and servos both drew peak current during hard braking and sharp steering inputs, the brownout protection on the ESC triggered intermittently. The car would suddenly lose throttle response and the AI would interpret the slowdown as a collision obstacle, overcorrecting into the wall. I solved it by adding a dedicated 5V 10A regulator fed directly from a high-drain lithium cell, isolated from the ESC power rail, and that fixed the erratic behavior immediately. Another issue that nobody talks about enough is tire temperature variance across the contact patch. Cold tires on one side of the car grip differently than warm tires on the other, especially after only a few laps. The model had learned to compensate for a uniform tire state during simulation, so the first real-world runs felt twitchy through medium-speed corners. I fixed it by adding a small amount of synthetic tire slip noise during training and by letting the car warm up two full sets of tires before recording the fine-tuning laps. After that, the steering corrections became noticeably smoother.

The Hardware And Software Stack Most People Actually Use

If you are starting from zero, the cheapest reliable path involves an Nvidia Jetson module for inference, a standard RC ESC with current sensing, a high-framerate global shutter camera if you can find one, and a flight controller or similar microcontroller running PID loops for low-level actuation. The AI model does not talk directly to the motors. It outputs target steering angle and throttle values, and the microcontroller handles the real-time safety margins and rate limiting. On the software side, most teams build around Python scripts that pipe camera frames into a PyTorch or ONNX runtime model. Data collection usually happens through ROS 2 nodes or custom MQTT publishers that log images, GPS or IMU data, and control commands at synchronized timestamps. Simulation often starts with tools like CARLA or specialized RC simulators, though some builders use Unity or Unreal projects tuned to match their track dimensions. The fine-tuning step typically runs on a desktop GPU and uses recorded laps as supervised data with imitation learning before switching back to reinforcement learning for final polish.

Pitfalls That Will Waste Your Weekend

The biggest mistake I see is assuming the simulator matches reality well enough to skip real-world calibration. It does not. Even when the physics look convincing, sensor noise, motor latency, and chassis flex create gaps that only appear during actual driving. You will save roughly three to five days of debugging by dedicating your first real track session entirely to data collection and baseline PID tuning before you ever load the neural network. A second mistake is letting the model optimize for top speed instead of lap consistency. Fast cars are easy to build. Cars that can run twenty laps without a dramatic loss in pace require regularization on steering outputs and explicit penalties for aggressive lane changes. The difference is usually between a car that looks impressive in a single demo run and a car that can actually compete in a timed session. There are also limits to what this approach can do. Weather changes, track surface degradation, and unexpected debris will break a model that was trained on clean, dry conditions. If your race environment includes rain or rubber buildup that shifts grip by more than fifteen percent, you should plan on either retraining with new data or fallback to manual control for those sessions. No current model I have tested handles sudden traction loss without explicit training examples that include it.

Where To Find Resources And Code

There is no single official download link for Janelle Is Training An Ai Powered Model Car as a complete product, because the work exists as a collection of research notes, demo videos, and partial code repositories shared across GitHub and a few hobbyist forums. If you want to follow the exact implementation, start by searching for the original project posts and then trace the linked repositories, since contributors frequently fork and modify the code for their own chassis sizes and camera mounts. For a practical starting point, look for open-source racing agent repositories that use end-to-end visual control on embedded hardware. Those projects contain the data pipeline templates, reward function examples, and inference optimization scripts you will need. Expect to spend time adapting them rather than copying them directly. The core ideas transfer easily, but the configuration details always need adjustment for your specific track and vehicle.

What This Means For The Hobby Going Forward

AI-powered model cars are moving from novelty to serious competition tooling, and that shift is happening faster than most club rulebooks can address. Some series are already adding classes that allow learned controllers with performance caps, while others ban onboard compute entirely. If you plan to race these cars, check the local regulations before you invest in expensive hardware. The technology works, but the competitive landscape is still figuring out how to contain it. My own recommendation is to treat the AI component as a supplement to good mechanical setup, not a replacement for it. A car with sloppy suspension geometry or misaligned steering will confuse any perception model, regardless of how well trained it is. Fix the hardware first, collect clean data second, and only then hand control over to the network. That order saves more time than any software shortcut ever will.