Team Hayes（Ajayaditya Lokchandra, Nithisha Venkatesh）です。自動運転AIチャレンジ2026 の公式解説動画 3 本（導入編、Autoware解説編、End to End AI編）は日本語のみで、英語字幕がありません。日本語が読めない参加者のために、各動画の内容を英語でまとめ、該当箇所へのタイムスタンプを付けました。日本語で見る方にも、目次として使えるように日本語の目次を先に置いています。

英語版は後半にあります。 / English version below.

対象の動画

動画	長さ	内容
解説 01：導入編	27:45	環境構築、開発の流れ、ローカル評価、提出
解説 02：Autoware解説編	23:02	縮小構成の Autoware、ノード構成を実際に追う
解説 03：End to End AI編	42:56	学習データの取得、TinyLidarNet と PilotNet の学習と走行、他車両の回避

日本語の目次

01：導入編

00:50 推奨環境（Ubuntu 22.04、GPU。LiDAR とカメラには NVIDIA GPU が必要）
02:30 2026 年からの変更（Docker Compose、セットアップスクリプト 1 本）
04:30 AWSIM と Autoware の起動確認
07:00 開発サイクル（編集、make autoware-build、make dev、make down）
13:15 ROS_DOMAIN_ID とトピックの確認
15:45 試しに pure pursuit のパラメータを変える
20:45 ローカル評価（make eval）
25:15 提出

02：Autoware解説編

03：End to End AI編

02:20 AWSIM のセンサー設定
03:40 手動走行で rosbag を記録
10:30 TinyLidarNet の学習とデプロイ
17:15 PilotNet の学習とデプロイ
22:00 アクセルを学習しない設定
24:40 シナリオエディターで他車両を置く
34:00 train/val 分割と Augmentation
37:00 TensorBoard で学習を確認
39:30 学習に使っていないシナリオで走らせる

作り方と注意

YouTube の日本語自動字幕を書き起こし、動画を見て内容を確かめてから英語にしました。コマンド、ファイル名、パラメータは、スターターキットのリポジトリとドキュメントの現在の内容と照合し、書かれているとおりの名前にしています。タイムスタンプは 15 秒程度ずれることがあります。動画の説明にもあるとおり、最新の情報はドキュメントサイトが正です。まとめの作成には AI コーディングエージェントを使いました。間違いがあればコメントでお知らせください。

English

Team Hayes (Ajayaditya Lokchandra, Nithisha Venkatesh). The JSAE AI Challenge 2026 has three official explainer videos, and all three are in Japanese with no English subtitles. This is an English summary of each, with timestamp links so you can jump to the part you need while following along on screen. Commands, file names and parameters were checked against the current starter kit and documentation, so you can copy them from here.

Two words the auto-captions and on-screen menus use a lot: AWSIM is the simulator, and RViz is the Autoware debug view on the right of the screen.

01: Getting started (27:45)

Watch. Follows the docs pages "Getting started", "Setup" and "Development guide".

Time	What happens
00:50	Requirements: an Ubuntu 22.04 PC with a GPU. An NVIDIA GPU or Intel integrated graphics both work, but the LiDAR and camera sensors need NVIDIA. PCs without a GPU can run it but are not officially supported.
01:30	The demo laptop is a 10th-gen Core i7 with a mobile GTX 1650. It works, but a slow PC can miss compute deadlines and drive worse.
02:30	New in 2026: Docker Compose, and one setup script (`setup.bash`, fetched with `curl`) replaces the old manual install. Answer Enter or `y` to its questions. It installs everything, builds the images and the workspace, and starts Autoware at the end.
04:30	Success check: AWSIM (left) and RViz (right) open, a countdown runs, and the kart drives. The track is a virtual City Circuit Tokyo Bay. The green line in RViz is the trajectory the kart follows.
05:30	The sample code only "roughly drives" and sometimes gets stuck. Improving it is the competition.
06:00	The repo is cloned to `~/aichallenge-racingkart`; `make down` stops everything. If nothing starts or it is very slow, see the GPU setup page: install Vulkan, and for NVIDIA also the NVIDIA Container Toolkit.
07:00	The development cycle: edit, build, run and check, repeat; then local evaluation; then submit.
08:00	`./docker_build.sh dev` builds the dev image (setup already did this; redo it after environment updates). Your code lives in `aichallenge/workspace/src/aichallenge_submit/`.
09:00	`make autoware-build`, then `make dev` to run, `make down` to stop.
10:30	RViz has capture buttons for screenshots and video. Captures and logs go to `output/`, one folder per date.
11:30	`make ps` shows two containers: `autoware` and `simulator`.
12:00	To debug with ROS commands, enter the Autoware container. The video uses `docker compose exec`; the docs now give `make autoware-attach` (existing container) or `make autoware-bash` (new container).
13:15	AWSIM and Autoware run on separate ROS domains: AWSIM is `ROS_DOMAIN_ID` 0, Autoware is 1. `export ROS_DOMAIN_ID=1`, then `ros2 topic list` and `ros2 topic echo /localization/kinematic_state` (timestamp, position, orientation, covariance).
15:00	The container is deleted when it exits, so files saved inside it are lost.
15:45	A first experiment from the "Development ideas" page. Four controllers ship with the kit: MPC (default), pure pursuit, TinyLidarNet and PilotNet.
17:30	In `aichallenge_submit_launch/launch/reference.launch.xml`, set `control_method` from `mpc` to `pure_pursuit`. In `launch/control/pure_pursuit.launch.xml`, change `lookahead_gain` 0.5 to 0.1 and `lookahead_min_distance` 3.5 to 1.5, so the controller looks much closer ahead.
19:30	Result: the kart zigzags even on the straight, like riding a bike while looking at your front wheel. A tight, twisty course might suit it, so this is a parameter to tune per course. The change is reverted. (A launch-file change does not need a rebuild.)
20:45	Local evaluation, made as close to the real scoring as possible: `./create_submit_file.bash` packs your code into `submit/aichallenge_submit.tar.gz` (this is the file you submit), `./docker_build.sh eval` builds an evaluation image that also compiles the workspace, then `make eval`. It stops after 6 laps and saves the results.
23:45	Driving by hand in AWSIM: click the A icon at the top left so it shows M, then use the arrow keys. Click D so it shows R to reverse.
24:30	`make eval` saves a capture video, a rosbag and a JSON file with lap times in `output/`.
25:15	Submit: rebuild the tarball if you changed code, log in to the online scoring site, Submit Code, choose the file, Submit. The server builds and races it, then shows the result and ranking. The video uses a development site, so the screens may differ.

02: Autoware (23:02)

Watch. Follows the docs page "Main module" (Autoware structure). The challenge uses a reduced Autoware with fewer nodes so you can understand it end to end.

Time	What happens
00:30	The usual pipeline: Sensing, Localization, Perception, Planning, Control. There is no Perception component by default; you can add one.
01:15	Sim to Real: AWSIM and the real kart use the same interface, so Autoware only has to subscribe and publish the agreed topics. Inputs: vehicle status (speed, steering), GNSS, IMU, and V2X (other karts' positions). The E2E AI class uses LiDAR and camera. The output is the control command (and a gear command if needed).
02:50	For the E2E AI class, the ideal is LiDAR and camera in, control command out.
03:15	The diagram in the docs is as of July 2026 and will change as you develop, so the video reads the live graph instead.
04:00	`make dev`, then `make autoware-attach` and pick `1` (the Autoware container). With ROS 2 on the host, simple commands work without entering the container.
05:15	Domains separate the karts: AWSIM is domain 0 and karts are domains 1 to 4. `make dev` runs one kart on domain 1. With `ROS_DOMAIN_ID=0`, `ros2 node list` shows only the AWSIM node; with `1` it shows the Autoware nodes.
07:20	`pip install dear-ros-node-viewer`. It installs to `~/.local/bin`, so run it from there or by full path, with `ROS_DOMAIN_ID=1`. Menu ROS > Load Current Graph reads the running system. Scroll to zoom, middle-drag to pan, drag nodes to arrange, Layout > Save to keep your layout.
10:15	A pre-arranged layout and image are on the racingkart GitHub wiki (node structure); download the zip and open the graph file with the viewer. Each box is a node: name on top, subscribed topics with a yellow dot on the left, published topics with a yellow dot on the right. Node name / Edge name > Full shows full names, Last only shortens them.
12:15	Layout of the graph: sensing nodes, localization nodes (blue), one planning node, one control node, three map nodes. AWSIM and the orchestrator are outside Autoware.
13:00	The AWSIM bridge node for domain 1 takes the control command in and sends vehicle status, GNSS and IMU out.
14:30	Localization ends in the EKF localizer, which takes a pose (position and heading, from GNSS and IMU) and a twist (speed and yaw rate, from vehicle status and IMU).
15:15	The racing-kart GNSS poser turns GNSS into a pose, but its heading comes from position changes and is inaccurate, so the IMU GNSS poser replaces it with the IMU heading. That node also offers a `set_initial_pose` service, which re-initialises the EKF. RViz 2D Pose Estimate does the same through the initial-pose relay.
16:50	Twist path: the vehicle velocity converter gives speed, the IMU corrector gives angular rate, and the gyro odometer combines them for the EKF.
17:30	The EKF fits pose and twist to a vehicle motion model and publishes `kinematic_state` (position and velocity), plus TF. Control mainly uses `kinematic_state`. The twist-to-accel node differentiates speed into acceleration; it feeds accel-map generation and is not used by control today, but you can use it.
18:30	Map nodes: the Lanelet2 map loader reads the `.osm` map and publishes the vector map; a visualisation node draws it in RViz; a TF generator links the map frame to the viewer frame. These three are outside the challenge's code and cannot be modified.
19:40	Planning is one node, the simple trajectory generator. It does not plan: it reads a prepared racing line from a CSV and publishes it as the trajectory. Optimising that CSV is a good first step for speed. Suggested next steps: plan from the vector map yourself, use V2X to plan around other karts, or adjust the CSV trajectory on the fly.
21:00	Control takes the trajectory and `kinematic_state`, computes acceleration and steering to follow the trajectory, and publishes the control command (to the kart itself on real hardware). MPC by default, pure pursuit as an alternative; V2X could also be used here.
22:00	With PilotNet or TinyLidarNet, the planning and control nodes are replaced by one node that reads the sensor and outputs the control command.

03: End to End AI (42:56)

Watch. Follows the docs pages "AI", "TinyLidarNet" and "PilotNet". It is hands-on and does not go deep into the models.

Time	What happens
00:30	End to end here means camera or LiDAR in, steering and acceleration (or a trajectory) out. Sample packages are provided and your own models are encouraged. The VLM planner and VAD planner samples run separately from Autoware.
01:15	Both models are supervised, so you need driving data. Prerequisite: a GPU setup where `make dev` already works. The flow: set AWSIM up for E2E, record data, train, run it in Autoware.
02:20	Step 1: in `aichallenge/simulator_scripts/dev.sh`, change `--camera off` and `--lidar off` to `gpu` (or `cpu` if `gpu` fails). If you use a different make target, edit its script instead. The E2E class cannot use IMU, GNSS or V2X, so turn those off to match race conditions; this does not affect data recording.
03:40	Step 2: "training data" means a rosbag of LiDAR, camera and the control command while the kart drives. Any driver works: gamepad, keyboard, or the default MPC (in that case keep IMU and GNSS on).
04:40	Manual driving: set `control_method` to `joycon` in `reference.launch.xml` (it covers keyboard too), then in `launch/control/joycon.launch.xml` set `input_source` from `joy` to `keyboard` (or `keyboard_x11` if `keyboard` does not respond). The key map is in the TinyLidarNet docs. AWSIM still says "Auto"; you drive with the keyboard.
06:30	In a second terminal: `make autoware-bash`, `cd` to `ml_workspace`, `export ROS_DOMAIN_ID=1`, check `ros2 topic list`, then `./record_data.bash`. Drive (the video does about 6 laps) and stop with Ctrl-C. Start and stop recording promptly so the bag has no idle data.
08:30	`make down` also kills the recording container. To stop only AWSIM and Autoware and keep that terminal: `docker compose down simulator autoware`.
09:15	Bags go to `ml_workspace/rawdata/<date>/` (a `metadata.yaml` and a compressed `.mcap`). Rename the folder to something meaningful, e.g. vehicle count, laps and run number.
10:30	TinyLidarNet Step 3 has five parts: copy bags to `train` and `val` (the same data here for simplicity; they should really be separate), convert bags to NumPy with `extract_data_from_bag.py`, train with `train.py` (PyTorch), convert `.pth` to `.npy` with `convert_weight.py` (inference runs on NumPy), and copy the weights into `tiny_lidar_net_controller/ckpt/`. All commands are on the docs page and can be pasted as-is.
13:30	Watch the loss fall; wait for the last epoch or Ctrl-C once it levels off. `checkpoints/` holds a best and a last model; use best. `git status` then shows `tinylidarnet_weights.npy` modified.
15:30	Step 4: `control_method` to `tiny_lidar_net`, and (only to prove the point) camera off in `dev.sh`. `make dev`; `ros2 node list` shows the TinyLidarNet controller node. It corners, jerkily, because it copied keyboard driving.
17:15	PilotNet: same steps from `ml_workspace/pilot_net`. Its dataset holds camera images as input instead of LiDAR scans.
19:40	Copy the weights into `pilot_net_controller/ckpt/`, set `control_method` to `pilot_net`, camera only. It drives and turns without hitting walls, with visible keyboard wobble.
22:00	Training settings are in `ml_workspace/<model>/config/train.yaml`. Acceleration is hard to learn; `python3 ./train.py train.loss.accel_weight=0.0` trains steering only. Then the model's acceleration output is meaningless, so set `control_mode: "fixed"` in `pilot_net_node.param.yaml` to use the fixed `acceleration` (0.6) instead. TinyLidarNet already defaults to `fixed`.
24:00	Applied part: training to drive around other karts and obstacles.
24:40	Camera and LiDAR back on, `control_method` back to `joycon`, `make dev`. In AWSIM click top, set Vehicles to 4, turn Scenario on, open Scenario Editor. Place each kart; the T mark is the front, rotate with the angle field; move the view with WASD like a game. Name the scenario under File and save, then save and start.
27:30	Record in the second terminal as before and drive around the other karts; stop right after the interesting part.
29:00	Repeat without restarting: keep the recording terminal, go back to top > Scenario Editor, load the saved scenario, move the karts (e.g. all to the left), save under a new name.
30:00	If AWSIM stays on "Waiting for start flag", run `make awsim-request-start` from a normal host terminal (it is in the FAQ).
32:00	Extra sample bags and test scenarios are attached to racingkart issue #259; copy their `rawdata` into yours.
33:15	Scenarios are YAML files in `aichallenge/simulator/AWSIM/AWSIM_Data/StreamingAssets/Scenarios/`; copy them to back up or share.
34:00	A proper split with augmentation (e.g. flipped images): copy bags into `ml_workspace/all`, convert, delete the old dataset, then `python3 prepare_data.py --all-dir ./dataset/all` creates `train` and `val`. In the video 427 MB became 682 MB train and 86 MB val; train grew because of augmentation.
37:00	TensorBoard: `pip install tensorboard` on the host, run it with `--logdir` pointing at `logs/` in the model folder, open the URL. Here train loss falls but has not converged, and validation loss does not fall at all. The presenter says plainly that this means the model is not learning properly and the data or method needs another look.
39:30	Test on a scenario not used for training: copy a test scenario from the issue #259 download into `Scenarios/`, then top, Vehicles 4, Scenario on, Browse, pick it, start.
41:45	It passes the other karts and makes the corners. A cardboard box is not avoided, because no boxes were in the training data.

How this was made

We transcribed YouTube's Japanese auto-captions, checked them against the video, and wrote the English. Auto-captions garble names (for example AWSIM and make dev), so every command, file name and parameter here was checked against the current starter kit and docs and written as it appears there. Timestamps can be off by about 15 seconds. As the videos themselves say, the docs site is the source of truth when they differ. We used AI coding agents to help write this. If you spot a mistake, please comment.

For the other English resources we added this year, see the guide for international participants and the glossary (live once docs #104 merges).