Made by: Jorrit Goossens
Table of Contents
- Introduction
- Goal
- Scope
- Initial scope
- Re-envisioned scope
- Training Environment
- Basic environment
- Circuit
- Machine Learning
- Programming Process
- Evolution manager
- Agent
- Neural network
- Neural layer / hidden layer
- Neurons / gene
- Genetic algorithm
- Fitness
- Data handling
- Result
- What would I implement afterwards?
- Complexity
- Performance & efficiency
- Analysis
- Reflection
- Terms
- Bibliography
- Theory & practice
- Illustrations
1. Introduction
The word AI is becoming increasingly popular in the present-day. The cleverest and most heavily trained AI are mostly driven by machine learning. Think about the first time they released the information of the Tesla’s and their “self-driving” capabilities, they were absolutely revolutionary to the consumer sector. Even to today’s standards, the Tesla’s Copilot functions are considered one of the best “self-driving” consumer friendly functions to a car.
Unfortunately the self-driving has to be put into brackets, due to the fact it is still not fully optimized to safety standards. Autonomous driving has five grades on which they base the capabilities of the systems cars bear. Some are very basic nowadays like ABS, but some newer ones are lane keep assist and adaptive cruise control, where the car could in theory drive for you. However, lane keep assist and adaptive cruise control do not come close to the surface of fully autonomous driving, since it is still flawed in different weather conditions, situational traffic occurrences and the state of the infrastructure you are driving on.
Weather conditions should be easier to train with machine learning, since you can practically and continuously train an AI upon weather conditions like aquaplaning, slippery roads, icy roads and snowy roads.
The situational traffic occurrences can not be fully practiced, due to the high number of different types of dangerous situations that happen, where you can only account for the accidents that the manufacturers have knowledge of, as each accident is different to the next. Even if an accident occurs, the autonomous car could not be at fault, but unfortunately also couldn’t prevent the accident.
The last problem is the state of the infrastructure you drive on. Some countries maintain their roads better than others. Countries have slight to big differences in markings, where North America uses yellow markings as standard and white markings when the road is under construction. In other countries this is the complete opposite.
All these differences add extra complexity to teaching AI to drive safely, which is nowadays is still an issue that has to be resolved by big car manufacturing brands like Tesla, BMW, Volkswagen group etc. To understand these difficulties I thought of this research subject and try the basics myself.
2. Goal
The goal of this research and development essay is to get a better understanding of how machine learning works. Machine learning is getting a hotter topic every day and I have taken an interest in it. In this essay I would like to create a deep reinforced machine learning tool that can learn how to get through a track using very basic car physics.
3. Scope
3.1 Initial scope
Phase one
It starts by making the mechanics, which are the cars and its movement and that you can insert input to move the cars.
Creating a circuit or a track is
First it starts by making the learning progress in C#, which is easiest to test in Unity. This starts by building a neural network, which extends into neural layers and neurons/weights. These neural networks are managed by a managing script.
The manager manages the cycles of generations, when the cycle starts and ends. It will activate the script that calculates the fitness of each agent.
After getting the fitness of each agent, the agents will be crossbred based on the two best agents.
Phase two
When the program works, the next step is to remove the bulk of calculations from the C# file and add it to a compute shader. Because these calculations are all the same, need to be done quick and are done at the same time, it is more efficient to run it through the GPU.
Phase three
At last the compute shader will be taken over by a C++ program that can run these calculations through the GPU. C++ has the capability to use NVIDIA’s improved cores called CUDA. However, after some research, HIP should be better due to the capabilities of running it through optimized NVIDIA and AMD cores.
3.2 Re-envisioned scope
After the first couple of weeks the scope has been re-envisioned and made smaller, due to the deadline that could not be reached by making compute shaders work and then the C++ as well, something a little unknown to me.
The re-envisioned scope will remove phase two and three, but it will add a little to the first phase. The first phase will add data handling that will save more than just the best agent. It will save all the progress of the evolution and the generational cycles with the best fitness’s.
4. Training Environment
4.1 Basic
The first environment is an environment which does not require intensive learning, so I am able to quickly check if the Neural Network I have made works.
The first environment is very simple, it will be a box where you have a starting point of agents (the agents are the green cubes) and a finishing point at the blue circle. The blue circle will be randomly located to different points in the box, so the agents learn to take different directions, instead of it learning to accelerate, decelerate, coast, steer left, steer right or steer straight.
4.2 Circuit
The next environment is going to consist of cars that train to finish a custom track. Firstly I will be making the cars to check if they work properly. Each car has a movement script in which you can insert player or data input to move them around. The car has the inputs to accelerate, decelerate and to steer left or right.
If no inputs are given for acceleration or deceleration the car will coast or keep still. No inputs for the steering would mean it would drive straight. Each car will have friction, so cars would slow down while coasting and they would have a maximum speed when they drive forward or reverse.
Tracks will be randomly designed by myself. Each track has barriers/walls which the cars cannot cross. To teach the AI how to get from point A to B, each track has waypoints that the cars have to cross. In the following illustration the waypoints are illustrated by the blue slabs. The car starts on the square blue slab and try to get to the last blue slab without crossing the barriers/walls, which are depicted by grey slim borders.
5. Machine Learning
In my understanding of what I have learned from Machine Learning so far, is that the learning process is mostly based upon how we as humans have been evolving in the older ages, where medicine and the understanding of health care was little to non. The time that survival of the fittest has been the reason for people to survive or die.
Darwin’s survival of the fittest is what I have used in my machine learning tool to teach agents to get from start to finish without hitting a wall. In the gif below shows how natural selection works. The frogs without camouflage to their environment will be easy pray compared to well camouflaged frogs.
Survival of the fittest is a theory where organisms gain advantages throughout generations of reproducing (What is natural selection? (2019, March 18). [Video]. Natural History Museum.). Each time organisms reproduce they will make successors with a genepool based on the mother’s and father’s genes. The genepool from the child will be 50/50, but it will not be expressed similarly. This is called gene dominance (Dominant. (n.d.). Genome.gov.), where one of the genes you have gotten expresses itself more than the other. For example: you have the gene to have blond or red hair, the gene of the blond hair is dominant, which makes your express the blond colour to your hair.
Mutations will occur during your life. This is due to the reproduction in cells where you can have them change parts of your genes. These mutations can have advantageous effects, but also negative effects. The frogs in the illustration video have mutated to camouflage to a wood colour, therefor harder for a predator to find them to eat. Because they are adapted to their environment based on evolution, they are the ones to survive and reproduce, where frogs that do not have camouflage, are more easily killed and unable to reproduce, slowly dying out.
An example of a negative way to reproduce is reproduction within the same family, where brothers and sisters or cousins reproduce is the Habsburgs (Megan Dillion. (2018) Consanguinity on the canvas: Studying inbreeding in the Habsburg Dynasty through portraits). In the ages of 1516 to 1700s there has been a Spanish royal family in power in parts of Europe. The habits of the family is to marry closely related family members to keep money and power within the family. This can have disastrous effects to the successors of parents, due to the negative mutations that are kept alive. When two parents have similar DNA due to close family relation, the child will inherit a very close genepool to both their parents, where the genepool of a child with non-related parents are vastly different in comparison. In the case of the Habsburgs, a recognisable appearance to the chin. This might not be a negative effect, however, there are also cases of inbreeding that result into genetic disorders to the child. The Whittakers is a very recent and prime example of the negative effects of inbreeding (Cost, B. (2023, April 3). Meet the Whittakers: Inside “America’s most inbred family” that speaks in grunts. New York Post). Where children are unable to communicate with other people, use grunts or squawks to make them heard due to their low IQ and mental disorders.
In the research I will be conducting I will be using neural networks as the brain to the agent. The neural network functions similarly like a brain. When we as humans see, hear, feel, smell or taste something, you would use your brain to process it. The exact same will be happening in the cars that will be driving on their own. Using sensors around the car, the car has to learn that to a certain proximity, the car would be damaged due to hitting a wall. So the brain, in this instance the neural network, has to understand what the distances of the sensors mean and how to act upon it, does it accelerate? decelerate? coast or stand still? steer left or right? or go straight ahead? This method of teaching I will use for the cars to drive towards its goal, the finish.
The genetic algorithms I will be using will stem off Darwin’s natural selection evolution theory. The neurons in this case will function for the genes, like every organism has. After each generation, genes will be crossed between the two best scoring agents to create new agents, their successors. These genes will be mutated by the genetic algorithm to create infinite possibilities of learning. Now the brain has new genes to work with that react differently than their predecessors.
In the next chapter I will be explaining and showing the code that has brought the machine learning tool to work.
6. Programming process
The following paragraphs of this chapter are individual scripts to create the machine learned AI (ArztSamuel. (n.d.). ArztSamuel/Applying_EANNs. GitHub. ). This will be the technical chapter of the research essay. The technical and non-technical part of the paragraph will be marked. Please make use of the Terms chapter if you do not understand a term.
6.1 Evolution Manager
The evolution manager will manage the machine learning process. It will start the evolution process by creating agents (Deciding the population, topology for the neural network layers), genetic algorithm and evaluating when an episode is finished (managing the “death” count of the cars, shutting down an episode when they all died or when the maximum amount of time has been surpassed) and putting the genetic algorithm to work to apply natural selection algorithms. After the natural selection algorithms are done, they are applied onto the agents and the Evolution Manager continues this cycle until the maximum number of generations have been created.
Technical
Before the evolution starts, it will need a number of parameters to be set. The user can put custom parameters in, where some parameters will have restrictions. The standard working numbers will always be shown in the fields, so you will have a reference with working numbers. The following parts of this chapter are parameters that are used for the evolution process.
Population size
The population size determines the number of agents that will be used for the evolution process. The minimum will be three agents, due to having at least two agents being able to be crossbred and kept afterwards. Three agents will not be advisable however, using three agents will be a very slow process of learning.
Number of generations
The number of generations depicts how many times the learning process will be run. One cycle of learning is a generation that will go through the environment to reach their goal. A generation stops when it either reached over the limited time or all agents hit the wall.
Episode time
The time each generation is allowed to run is ruled by the episode time. If the episode time is reached, the episode will stop and its data will be used to create a new generation and start the next episode, until the number of generations is reached.
Topology
Currently managing the topology from the menu is not yet possible, however, this would be added if I pursue this projects possibilities. The Topology will set the amount of neural layers / hidden layers and how many neurons / genes each of them will hold. The bigger the topology will be, the bigger the load will be for the calculations (Relation between Topology and Machine Learning. (n.d.)).
Input threshold
The input threshold was originally made for the fairness to the user. The user would only be able to use keys that would not have the ability to 20% steer or accelerate, but would always hit a 100% or 0%. The input threshold would use the received numbers from the neural network, which is a number between zero and one. For example, from 0 to 0.25 the car would go decelerate or steer left, from 0.25> to <0.75 the car will coast, stand still or not steer and from 0.75 to 1 the car will accelerate or steer right. In the illustration below is shown how it would work with acceleration or deceleration.
Gene cross probability
The gene cross probability determines the chance of getting a gene crossed from one of the parent agents. When the genetic algorithm is creating new agents, it starts with finding the two best agents, these two agents are the parents. Agents are created in pairs, where each of them are identical to one of the parents. The gene cross probability mixes up the genes from the two parents to the two new agents. The chance of them is determined by the gene cross probability, which is a number between zero and one, zero meaning 0% chance and one meaning 100% chance.
Mutation probability
The mutation probability determines the chance of a gene mutating. The agents need to be mutated to have an infinite chance of getting better, while it would run out of options if it would only crossbreed agents. The mutation probability uses the same technique to determine the chance as the gene cross probability.
Amount of mutation
The amount of mutation determines the number of mutation that is added as a mutation. Lower numbers would mean that the mutation will change only a little, where higher numbers would show significant differences.
6.2 Agent
Non-technical
The agent represents the car in this research subject. The agent is the communicator between the Neural network and the movement of the car. The neural network will communicate what the car has to do in terms of accelerating the car or steering the car.
The car itself has ten sensors, these sensors send its data (the distance between the car and a possible wall) to the neural network. The data from these sensors enable the network to understand the situation the agent is in.
If the car hits a wall, it will tell it has crashed and seizes all movement. At this point the agent awaits the genetic algorithm to get its new and possibly improved data to try to get further.
Technical
An agent will manage their own ‘death’ if they crash against the barriers of the track. This is done by the OnTriggerEnter function checking for the barrier layer. The OnTriggerEnter also adds the checkpoints to the fitness system, so the machine learning process understands it is good to get through the checkpoints.
To make sure the car will learn where it has to go, the completion percentage of getting to the next waypoint is calculated too, this speeds up the process by getting the actual best performing agents from the epoch. The completed percentage of a waypoint is calculated by the distance between two waypoints and the distance the agent is from the next waypoint.
To insert input data into the neural network, you will need to know what the agent has to learn from. In this case, the car will act upon its sensors. The car is set up with ten sensors, five at the front of the car and five at the back. These ten sensors return the distance from its start position till it hits a barrier. The input array that is send to the neural network will be the ten distances from the sensor. In the following illustration are the sensors illustrated by blue lines.
Quickly after the agent has send the Neural network its input data, it will receive the output data. The output data is designed upon the behaviour of the agent. The agent in this situation is a car, which as is mentioned before, can steer left and right, and accelerate and decelerate. I envisioned these parameters to be the same to the inputs I would use myself to control the car in Unity. These inputs would be either wasd or the pointer keys, which would require a Vector2, where the axis’ orientate the movement of the car on the same axis’. For each axis the agent receives output data from the neural network, where the output data will be between the zero and one. I have decided that under the 0.2 it would insert minus one and above 0.8 it will insert a 1 to the axis. This means if the x-axis (steering inputs) receives under 0.2, it will steer left, between 0.2 and 0.8 it will steer straight and above 0.8 it will steer right. The same goes for the y-axis (accelerate and decelerate inputs), which it would decelerate, coast and accelerate with the same numbers in the same order.
The code block above is the epoch of the basic environment training.
The code block above is the epoch of the circuit environment training.
6.3 Neural Network
Non-technical
The neural network is the holder of all learning information. It sets the values for the neurons from each neuron layer and sends them to the genetic algorithm. You could interpret the neural network to be the brain stem of your agent, it sends the messages of the brain to your body and receives messages from your nerves all over your body.
Technical
Each neural network consists of neural layers. The neural network starts by creating neural layers (the amount is decided by the length of the topology minus two (input and output layer do not count)). Each layer will be given two values from the topology, which determines the amount of inputs it will get and the amount of outputs it will send.
The neural network will receive data from the agent, which are the inputs for the neural layers. The first neural layer will receive the inputs from the agent, in this case ten inputs which are the distances of each sensor. The layer makes a calculation and sends that to the next layer, this repeats until the last layer is reached. The last layer will be the layer that outputs the data to the car, in this case two outputs, one for steering and one for acceleration and deceleration. The output from the last layer will be send by the neural network to the agent, where the agent will be moving the car.
6.4 Neural Layer / Genotype
Non-Technical
The neural layers combined is the brain. The neural layers process the data given to them and return what they have learned. Data is interpreted by neurons, which either activate or stay inactive based on the data. You can decide how many neural layers and/or neurons you would like to have. By high complexity (many actuators) it is advised to use a higher amount of Neural layers and/or neurons than lower complexity Machine learning AI. For example, in this current research subject there are ten sensors used, which is a low amount of actuators to calculate data from. It would be more complex if it has to add sign recognition, where the data is a picture. To the neural network, each pixel is an actuator. That would mean a full high definition picture (1920×1080) has 2,073,600 actuators, which is a significant increase from ten.
Technical
The neural layer comes forth from the neural network and contains all the neurons and data to learn. It firstly sets the weights and biases from each neuron. The amount of neurons is based on the topology.
Each epoch the neural layer calculates the outputs based on the inputs it has gotten, where the first neural layer will get the input parameters from the sensors (Sebastian Lague. (2022, August 12). How to Create a Neural Network (and Train it to Identify Doodles) [Video]. YouTube). The last neural layer will send an output of numbers to the agent, to move the car. The input could be seen as one of the senses of the car and the output is the reaction the car should make.
6.5 Neurons / Gene
Technical
Every neuron is created by the Neural layer. A neuron holds a number, the number is generated by random. The neuron will go through an activation formula, which will return a number between minus one and one. The number between minus one and one is chosen to create an easy output number for the steering and acceleration (minus one being decelerating/steering left).
6.6 Genetic Algorithm
Non-Technical
The genetic algorithm is the part that is based on Darwin’s natural selection or survival of the fittest. The two fittest agents, so the cars who have gone the furthest, will be reproduce to get a whole new population.
Each agent will be getting genes from both the cars. To re-enact gene dominance, genes will be given based on a calculation. The calculation will give the new agent a gene based on a 50/50 chance, however, using this calculation will have a very low chance of getting an exact 50/50 share of genes, but for example deviates to 48% and 52% (48/52).
After creating the genepool for the new agent, the genes get mutated. These mutations make sure each new agent has the opportunity to get better results than their successors.
Technical
After each episode the data of every genotype is evaluated. The Neural networks will be ranked based on its fitness and the two best performing genotypes will be the parent agents for the new generation. The new generation of genotypes will get mixed data based on both their parents and then mutated to change its actions from its parents.
6.7 Fitness
Non-Technical
The term Fitness comes from Darwin’s evolution theory. The fittest (most healthy in terms of human evolution) members of society prosper and get to have successors. The fitness will be determined on how far the car has gotten in the circuit, wanting the car that reaches the finish.
Technical
Each Neural network will have its own fitness. The fitness in this machine learning AI will be determined by the distance the car is from the next checkpoint, the time it sets per checkpoint and the overall time. To do this, each complexity that has a fitness will be set apart. The program will save two cars from each fitness with the best scores and the two cars with the best overall scores.
The best fitness outcomes will be crossbred to create a new generation or batch of cars.
6.8 Data Handling
Technical
As you run the program, the first thing done is making a folder for the day and the next folder for the evolution name. Data will be saved in a binary file to keep the amount of data usage low. The first data file will be all the parameters you have set for the evolution, for example: the population size, number of generational cycles, the percentage of chance a car crossbreds its weights etc.
After each episode the agents are sorted by their fitness scores, after each fitness score the data from the best agent is send to the DataHandler. The DataHandler will keep the best of each generation until the complete evolution is done. These files are also saved in binary and kept in a subfolder of the evolution folder.
In the following illustration you will see the structure of the files. At first you see the dates, which will lead to the evolution processes run on that day. In the evolution folder will be the binary file of the evolution data. In the subfolder Generations you will find an array of generation data ordered from first to last generation that has run through the evolution process.
The binary files of the generations can be used to show and use the AI through an environment. The evolution data could be used if you want to further evolve the existing AI or if you want to reuse it.
6.9 Result
In the following embedded Youtube video you will see a complete process of creating an AI and using it.
7. What would I implement afterwards?
7.1 Complexity
Currently I have made one type of fitness check, where it checks if the agent has passed certain waypoints and what percentage of distance the agent is to the next waypoint.
To further improve the agent is to check its time and improve it if the agent is able without hitting walls. The time check should only be done when the agent has reached the finish without hitting walls.
You could also add more obstacles and problems for the agent to solve, this adds to the complexity of learning. As earlier explained, the addition of complexity would add a lot to the load of a neural network. The fitness check will be harder to calculate as well. To improve the calculations of complexity and how we determine priority should be made in a modular system of fitness checking. My personal idea is to have a fitness for each rule or optimization the agent can work towards. The different fitness types should be labeled by rule or optimization. Rules have highest priority, the user could possibly create a priority list for the rules if it is preferred (example: the car can not crash into the wall). The optimizations should definitely be put into an ordered list or an algorithm (example: get the car from A to B the fastest).
The
7.2 Performance & Efficiency improvement
Increasing complexity increases the demand of processing power. To keep performance in check, the calculations run in epochs and episodes can be done in the GPU. The GPU strength is parallel calculations if the calculations are all run with the same script. My first idea was to run it through C++, where I can utilize the GPU and HIP/CUDA cores, these cores are optimized and run faster if you use its software. However, I first wanted to test it using compute shaders in Unity, since compute shaders are more familiar to me and work quite similarly as HIP/CUDA C++ software. When I make both C++ and compute shader calculation scripts, I want to test them in terms of performance and efficiency.
Efficiency could be improved with gradient descent, which is a method that is able to find better results quicker for agents (Sebastian Lague. (2022, August 12). How to Create a Neural Network (and Train it to Identify Doodles) [Video]. YouTube). Calculus can help significantly to create shorter calculation times by shortening formulas. For example, multiple calculations in a row could possibly be shortened by calculus, creating a single shorter calculation or a formula can shortened by itself.
The idea I have given earlier on the complexity and having more fitness types that are either rules or optimizations, could also increase the efficiency of finding the best agent overall. My idea is finding the similarity between agents that have been performing well at particular fitness types. These similarities can be checked with agents that do poorly on their specific fitness, so you can find the optimized neurons/genes. Using this information you would theoretically be able to build the best agent yourself or you can train upon the build of “good neurons/genes”.
A possibility at last is real time changes to the agents. Where agents can learn while they are interacting with their environment before they are evaluated from best to worst fitness. The downside of this approach is the gigantic need of performance of a computer and the evaluation of the maker which frequency of checks is desirable.
7.3 Analysis
Currently I have not made any files that can easily been read by people or other programs. To enable people or other programs to easily read the data from the evolutions, generations and the calculations you will be able to make, I would choose to create a CSV file. Programming languages like Python, React etc. are well-known for their ability to easily create a dashboard to visualize the data. Besides programming languages, Excel can be easily utilized for most people to read the data.
Data in the CSV file will consist of both the evolution and generation data. However, due to relevancy to agents being efficient and performing excellently, certain calculations could be made in C# or C++. Calculations like median or average fitness of a generation, timing of crossing the finish or waypoints.
At the end of an evolution, it is best to understand how well your AI performs and if it is usable for the use-case you have made the AI for, this is what you use the CSV files for. It would even better if it is shown while training the agents, however, this would cost extra resources in terms of processing power.
8. Reflection
Personally, I would have liked to gotten as far as my initial scope. However, in retrospect, that would have been impossible with the amount of work I must have done to finish the research.
The makings of the environments were easy and the same goes with the movement of the cars. Environments being made within a couple of minutes to half an hour for the circuit. Creating the cars and the movement took around a day from where I started creating the machine learning tool.
Creating the machine learning tool was the hardest. It took quite some time to understand the reasoning of functions, calculations and logic. This has been one of the most time consuming parts of making the program.
Part of the process that took loads of time, was finding a bug I had written. I had a hard time finding my mistake and in retrospect, I think I haven’t been very clearheaded when I tried to find the bug. I should have been more thorough and thought logically to find the issue. This has cost me too much time, until I made the basic environment, where the issue was easier to spot. So in retrospect, I should dial down the complexity of the environment to find the problem.
Making the machine learning tool was the hardest. I always set a high standard of logic and modularity in my scripts, so I am easily able to use the scripts and change them without a great hassle. However, the further I got into the project, I had less time to spend for perfectly modular scripts. Therefor the standard along the process of creating everything slowly slummed into partly “spaghetti” code. When I will be having more free time in the future, I would like to clean my code up and do my part to improve efficiency and performance and add complexity to the agents.
The last time consuming part has been the data handling. Creating all the folders correctly, getting the data, saving it to binary and loading it. I have tried to make it as modular as I could in the timeframe I had set, which was a little optimistic. Currently you are able to create an AI and see how it learning process is progressing. After which you can use the best agent of each generation to drive through the parkour. I would like to add function that continues an already created evolution, which you where able to see in the menu of the program.
When I look at the progress, I see ups and downs in the progress I have made. After all, I think I have put up a really good program to show the basics of machine learning. I have been unable to show what deep reinforced machine learning can do and how it works, but that would be a further endeavour for myself.
9. Terms
AI
AI is the abbreviation of Artificial Intelligence.
Agent
An agent is a single entity that is using the Machine learned data to test its capabilities. In the environment of this research, the car will be the agent using sensors.
Natural selection/Survival of the fittest
Natural selection is a term created by Darwin’s evolution theory. The agents that have the best results in the environment of this research, will have their neurons used to create a new generation of agents.
Epoch
An epoch is one iteration of data that is send through the neural network. This means it will have gotten one array of data from the input and gets one array of data as output to use for the object you are teaching. In less technical terms, it is the time of one observation. For example: The instant the agent recognises that the distance between the car and a wall is too close from the input of the sensors, to the reaction of the agent giving an output to steer away the car from the wall.
the exact moment you see the red light going green and your brain sends a signal to your feet to hit the gas pedal.
Episode
An episode is the start to finish process of a generation going through the learning process.
Evolution
An evolution is the start to finish process of all generations going through the learning process.
Activations
The following activations are algorithms used to get a number between zero and one. The frequency of getting a higher or lower number is different in each of the algorithms, therefor useful. In some cases you would like linear frequency where in some cases you might want an exponential frequency of higher and lower numbers.
Sigmoid
TanH
RelU
10. Bibliography
10.1 Theory & practice
C# Evolutionary Artificial Neural Network
ArztSamuel. (n.d.). · ArztSamuel/Applying_EANNs. GitHub.
https://github.com/ArztSamuel/Applying_EANNs
C# How to create a Neural network
Sebastian Lague. (2022, August 12). How to Create a Neural Network (and Train it to Identify Doodles) [Video]. YouTube.
https://www.youtube.com/watch?v=hfMk-kjRv4c
C++ Neural network inmplementation
Abhishek Pandey. (2018, September 11). Neural Net implementation in C++ [Video]. YouTube.
https://www.youtube.com/watch?v=sK9AbJ4P8ao&list=PLxgr_dYeb02SuShcDX5NIXkwaAHf3A9J5&index=1&t=642s&ab_channel=AbhishekPandey
What is Topology?
Relation between Topology and Machine Learning. (n.d.).
https://www.tutorialspoint.com/relation-between-topology-and-machine-learning#:~:text=Topology%20offers%20a%20mechanism%20to,lot%20of%20features%20or%20variables
Survival of the fittest
What is natural selection? (2019, March 18). [Video]. Natural History Museum.
https://www.nhm.ac.uk/discover/what-is-natural-selection.html
Gene dominance
Dominant. (n.d.). Genome.gov.
https://www.genome.gov/genetics-glossary/Dominant#:~:text=A%20dominant%20gene%2C%20or%20a,in%20this%20case%2C%20the%20recessive.
Habsburg inbreeding
Megan Dillion. (2018) Consanguinity on the canvas: Studying inbreeding in the Habsburg Dynasty through portraits.
https://digitalcommons.unl.edu/cgi/viewcontent.cgi?article=1010&context=ureca
The Whittakers
Cost, B. (2023, April 3). Meet the Whittakers: Inside “America’s most inbred family” that speaks in grunts. New York Post.
https://nypost.com/2023/04/03/meet-the-whittakers-inside-americas-most-inbred-family/
10.2 Illustrations
Neural network gif
Yadav, S. (2022, June 21). In-Depth knowledge of convolutional neural networks. Medium.
https://medium.com/@Suraj_Yadav/in-depth-knowledge-of-convolutional-neural-networks-b4bfff8145ab
Natural selection gif
Natural selection on make a GIF. (n.d.). MakeAGif.
https://makeagif.com/i/Qj4PiD
