Top AI Repos — open-source AI, indexed and scored
Top AI Repos tracks AI repositories on GitHub and answers two different questions about each one: is it moving right now, and would you bet a product on it.
Top AI Repos tracks AI repositories on GitHub and answers two different questions about each one: is it moving right now, and would you bet a product on it.
Self-Driving Truck in Euro Truck Simulator 2, trained via Reinforcement Learning
| Date | Stars |
|---|---|
| 2026-07-24 | 411 |
| 2026-07-25 | 411 |
| 2026-07-28 | 411 |
| 2026-07-30 | 411 |
| 2026-07-31 | 411 |
| 2026-08-06 | 411 |
Today
— stars today
This week
— stars this week
This month
— stars this month
Momentum
0.0
growth rate 0.00%/day
# About This repository contains code to train and run a self-driving truck in Euro Truck Simulator 2. The resulting AI will automatically steer, accelerate and brake. It is trained (mostly) via reinforcement learning and only has access to the buttons W, A, S and D (i.e. it can not directly set the steering wheel angle). Example video: [](https://www.youtube.com/watch?v=59iNsSnAUfA) # Architecture and method The basic training method follows the standard reinforcement learning approach from the original [Atari paper](https://arxiv.org/abs/1312.5602). Additionally, a separation of Q-values in V (value) and A (advantage) - as described in [Dueling Network Architectures for Deep Reinforcement Learning](https://arxiv.org/abs/1511.06581) - is used. Further, the model tries to predict future states and rewards, similar to the description in [Deep Successor Reinforcement Learning](https://arxiv.org/abs/1606.02396). (While that paper uses only predictions for the next timestep, here predictions for the next T timesteps are generated via an LSTM.) To make training faster, a semi-supervised pretraining is applied to the first stage of the whole model (similar to [Loss is its own Reward: Self-Supervision for Reinforcement Learning](https://arxiv.org/abs/1612.07307v2), though here only applied once at the start). That training uses some manually created annotations (e.g. positions of cars and lanes in example images) as well as some automatically generated ones (e.g. canny edges, optical flow). Architecture visualization:  There are five components: * Embedder 1: A CNN that is pretrained in semi-supervised fashion. The two gradient inputs (see image) are just gradients from `1` to `0` which are supposed to give positional information. (E.g. the mirrors are always at roughly the same positions, so it is logical to detect them partially by their position.) Instance Normalization was used, because Batch Normalization regularly broke, resulting in zero-only vectors during test/eval (seemed like a bug in the framework, would usually go away when using batch sizes >= 2 or staying in training mode). * Embedder 2: Takes the results of Embedder 1 and converts them into a vector. Additional inputs are added here. (These are: (1) Previous actions, (2) whether the gear is in reverse mode, (3) steering wheel position, (4) previous and current speeds. The current gear state and the speed is read out from the route advisor. The steering wheel position is approximated using a separate CNN.) Not merging this component with Embedder 1 allows to theoretically keep the weights from pretraining fixed. * Direct Reward: A model that predicts the direct reward, i.e. for `(s, a, r), (s', a', r')` it predicts `r` when being in `s'`. The reward is bound to the range -100 to +100. It predicts the reward value using a softmax over 100 bins. * Indirect Reward: A model that predicts future rewards, i.e. for `(s, a, r), (s', a', r'), ...` it predicts `r + gamma*r' + gamma^2*r''` when being in state `s`. Gamma is set to `0.95`. This model uses standard regression. It predicts one value per action, i.e. `Q(s, a)`. * Successors: An RNN model that predicts future embeddings (when specific actions are chosen). These future embeddings can then be used to predict future direct and indirect rewards (using the two previous models). This module uses an addition to the previously generated embedding (i.e. residual architecture). That way the LSTMs only have to predict the changes (of the embeddings) that were caused by the actions. Aside from these, there is also an autoencoder component applied to the embeddings of Embedder 2. However, that component is only trained for some batches, so it is skipped here. During application, each game state (i.e. frame/screenshot at 10fps) is embedded via convolutions and fully connected layers to a vector. From tha
Excerpt of 20,133 characters
Read on GitHubWould you bet a product on this? Bounded 0–100 and slow moving.
matched fp:8368af1582457605, topic:deep-learning, topic:pytorch, readme:pretraining
matched fp:8368af1582457605, topic:reinforcement-learning, desc:reinforcement learning, readme:reinforcement learning
matched fp:8368af1582457605, topic:self-driving-car, name:self-driving, desc:self-driving