Embedded Files
In this project, we were tasked with coming up with a solution plan for any world problem, large or small. My group decided to solve the problem of car crashes. To start, we researched what the causes of car crashes were. We found that a staggering 94% of all crashes are due to driver error alone, clearly suggesting that the root cause of car crashes is simply driver failure. To support this, nearly one-third of all crashes occur with only one car, which can only be the case if the driver simply makes a mistake.
Continuing on with the research, we found that you are 23 times more likely to crash while texting, and that over 80% of drivers use their phone while driving. This further advances the idea that drivers are the cause of most car crashes. Additionally, seatbelts can reduce the risk of injury or death in a crash by 45%, but 1 out of every 7 people don't wear their seatbelt! We found more and more facts that all point to the same thing: to fix the problem of car crashes, we need to eliminate the driver. More of these statistics can be found in the slideshow below.
Once our research was complete, we began brainstorming. The quick conclusion was that a self-driving car would be the best avenue to completely remove the need for driver control. For our solution, I decided to make a prototype of the logic that goes on behind self-driving cars. I created a simulation using the OpenProcessing platform to host p5.js code (a graphics library for javascript), allowing you to see (in real time) how the "car" is making decisions. All decisions are made by multiple neural networks, one to control the driving and one to recognize images. The driving neural network receives its data from five lidar-like distance sensors located around the car and was trained on a sample of how I "drove" the simulated car; the image-classification network was trained on a variety of "obstacle" and "non-obstacle" images. While the driving network is working in complete real-time, the image classifier's results were pre-classified to keep the performance of the simulation high (however in real life this would be done on the fly as well).
This prototyping process took quite some time; getting the car to accurately identify relationships between the sensor input and the desired driving output was difficult at times. An issue that occurred was when the car tried too aggressively to maintain its state of "equilibrium" in the middle of the road — as soon as a corner arrived, it would swerve violently to try and keep itself in a perfect position. However, this would be much too violent for passengers and nearby cars, so I had to dampen some of the training sets in order for it to not have too much acceleration. I kept revising and revising the solution, and by the end the car would successfully perform the tasks around the simulated environment. This included (in order of difficulty):
Staying on the road
Braking at corners to keep the ride smooth
Recognizing obstacles (such as a ball) that do not need to be avoided
Recognizing obstacles (such as a pedestrian) that do need to be avoided
The simulation can be found below.
The Presentation
The Presentation
The Simulation
The Simulation
The Engineering Design Cycle
The Engineering Design Cycle
Ask: Identify the Needs and Constraints
Ask: Identify the Needs and Constraints
We identified that a solution needs to be devised which prevents car crashes before they happen. It had to be portable (able to work on a car) and practical (relatively cheap to implement).
Research
Research
We did extensive research on the causes of car crashes and what factors can influence a crash. Much of our research can be found in the presentation above.
Imagine and Plan
Imagine and Plan
While we had many possible solutions (our most prominent ideas shown in the slideshow above), we settled on the idea of a self-driving car because it is the most preventive measure possible.
Create a Prototype
Create a Prototype
I built the simulation so that we could have an easy-to-update and modifiable platform to test the logic.
Test and Improve:
Test and Improve:
I constantly revised the simulation, adding new features as I went. When things didn't work right, I rebuilt and modified it in order to fix and improve it.
Core Concepts
Core Concepts
Neural Network
Neural Network
A neural network is a system for creating an algorithm that finds a relation. The important aspect of a neural network is that (in general) the algorithm creates itself by learning from test set. This is the most common use of neural networks (and thus inspires their name), because obviously a system which is able to "self-learn" is extremely useful.
The math behind how a neural network works is rather complicated and involves a good deal of work, but this is irrelevant for understanding the concept behind a neural network. A neural network works by taking a set of input numbers, "feeding them through" a series of hidden "layers" that modify the values in some way, and then getting an output through the output layer. (Refer to the diagram at left for a visualization of this.) During the training process, the network attempts to figure out what transformations in the hidden layers make the given example inputs in the test set map to the given example outputs in the test set. By repeatedly training over all the test sets, a complex network can correctly find relationships in just about anything — sensor values to motor movements, images to their names, etc. (Of course, the latter requires a good deal of transformation work, converting numbers to names and images to numbers.)
Loss
Loss
With respect to neural networks, "loss" refers to how bad the neural network is at mapping the test inputs to the outputs. Ideally, you want this to go to zero as you train the network more, indicating that the network is very good at finding the relationship. In the simulation, the graph at the start shows the loss of the car's driving network while it trains. (You can click "hide" to minimize this graph once fully-trained.)
LIDAR
LIDAR
LIDAR is a laser-based system which finds distances by bouncing a laser off objects and measuring the time it takes. Since the speed of light is not infinite, longer times for the light to bounce back means a larger distance. In a traditional LIDAR system, the laser rotates around rapidly in order to cover all areas around the sensor. In this way, it can create a 3D map of its surroundings. LIDAR's downside is that it cannot recognize color, so it is poor at identifying what objects are. However, a camera can be used for that effect.
Reflection
Reflection
In total, this project went fairly well for me. My critical thinking for this project was definitely great, because I had to really think to make the simulation work properly. It was a great application of some programming skills I had learned but had never really applied very far. Additionally, this project was a positive experience with regard to conscientious learning. I worked really hard on the simulation and put a lot of time into it to make it work fully. I was very focused and very determined to complete it in time. So, this project was great for expanding all aspects of cognitive ability.
As usual, it wasn't perfect though. I don't think I communicated about my simulation enough to my group. When I struggle with something, I usually just keep to myself if it's something that I'm basically the only one working on, but I should reach out to my group regardless and ask their opinion on what strategies I should try (in order to solve the problem). Also, my conscientious learning wasn't perfect in respect to the presentation. Because I was devoting so much work into the simulation, I didn't focus as much on the presentation as I would've liked to, so perhaps I should've spent even more time so that I could have checked it more thoroughly. However, overall I think this project was mostly positive.
Page updated
Report abuse