Self-driving cars have a major impact in the future of transportation and will be able to increase mobility for many people; however, they still need to be less accident-prone before they can become commonplace. Due to its impact and extensive real-world applications, we decided to work on training a less accident-prone car.

What it does

Our machine learning model learns from the training data we generated during our manual driving runs in Udacity’s self-driving simulation. Our data recorded every angle change we made while moving the car, and pictures taken from three cameras at every angle change. In generating the data, good driving (staying on the road and not swerving), the machine also learned to drive with these safe practices. Our data shows that during training, the model’s training loss decreased almost consistently, which means that the autonomous model learned and improved from our data at each epoch (training round).

How we built it

We started by using Udacity to gather data. We manually drove the car around a virtual environment, using the record function to collect our user data. We began to train a new model based off that data. How that works is the computer attempts its own drive around the track, which is typically unsatisfactory. It compares that drive to the user data we collected earlier. The difference between the computer attempt and the user data is called loss, where greater loss means a worse attempt on the computer’s part. It recognizes which actions resulted in lowering the loss value, and saves its progress before moving on the the next level, or epoch. Now the computer repeats the process, attempting a drive around the track but this time with the previous results in mind. It recognizes which patterns result in a closer adherence to the user data, and this is concatenated with each epoch. Once we reach the last epoch, we have completed our set training tests, with loss minimized as much as possible. We use Udacity to test the model in an autonomous setting, and see its results.

Challenges we ran into

Because of the virtual environment for Technica, it was a challenge to efficiently collaborate since we used different computers and operating systems. We ran into problems with software downloads being slightly different for each team member, and it took a lot of time to determine the source of the error since we could not see everyone’s screens. Furthermore, due to the nature of machine learning, it can take many hours for our processors to train models. Because of our time limit, we were not able to train our model as long as we wanted to.

Accomplishments that we're proud of

We were able to successfully train a car to drive autonomously without crashing after 10 laps in a virtual environment, and we learned how to use Anaconda, Unity, Linux, and Tensorflow. We were able to work cohesively as a group despite being in a virtual environment.

What we learned

We learned more about machine learning and autonomous driving conceptually, and we also learned how to utilize new technologies, such as Tensorflow and Unity, in order to train a model. Additionally, we learned how to create a conda environment.

What's next for Autonomous Driving via Accident Analytics

The extensive autonomous driving training necessary for self-driving cars to one day be ubiquitous can only be realistically done virtually to avoid human harm and the high costs of property damage. In the future, we hope to learn and use Unity to create our own environments, and then train a self-driving car in wide-ranging situations they may encounter. By simulating and training a self-driving car in new environments, we aim to create autonomous driving models that can better handle anomalous road conditions as well as increase safety. While conducting the training tests, we also plan to analyze data generated from the training runs and adjust the hyperparameters (such as learning rate, test size, and batch size) of the file with the objective of reducing the loss.

Built With

Share this project: