Analogical Study of Activation Concept in Neural Networks with Neat- Python Module

Flappy Bird is a popular mobile game that was released in 2013. The objective of the game is to guide a bird through a series of pipes without touching them. The bird can be controlled by tapping the screen, causing it to flap its wings and gain altitude.

One approach to designing an AI agent that can play Flappy Bird is to use the NEAT (NeuroEvolution of Augmenting Topologies) algorithm. NEAT is an evolutionary algorithm that evolves neural networks with complex topologies by adding and removing nodes and connections.

To apply NEAT to Flappy Bird, we can represent the game state as inputs to a neural network. These inputs could include the bird's height, the distance to the nearest pipe, and the height of the opening in the pipe. The neural network would then output a single value indicating whether the bird should flap or not.

During each generation, a population of neural networks is created and evaluated by playing Flappy Bird. The networks that perform the best are selected to reproduce and create a new generation of networks. Through this process of selection, reproduction, and mutation, the neural networks evolve over time to become better at playing Flappy Bird.

The NEAT algorithm has been successfully applied to Flappy Bird, resulting in AI agents that can achieve high scores and outperform human players. This demonstrates the power of evolutionary algorithms and their ability to solve complex problems.

The machine learning approach known as NEAT (Neuroevolution of Augmenting Topologies), developed by Kenneth O. Stanley, involves training a neural network using evolutionary techniques [1]. Using an evolutionary algorithm, the best-performing networks are chosen from a population of neural networks with varied topologies (i.e., different numbers and configurations of neurons and connections) to breed and generate the following generation of networks.

In the well-known smartphone game Flappy Bird, the user must lead a bird between the spaces between ordinarily placed pipes. It's a popular game that was first developed for mobile platforms [2]. Its only goal is to maintain the player or bird's life, extending as far as possible by avoiding contact with the other pair while navigating a space between two pairs. Figure 1 below depicts the various game phases.

The game's gameplay is extremely straightforward: at every moment, the player has a choice between two options: touching the screen to cause the bird to fly higher or doing nothing to cause it to drop [3]. By modifying the connections and weights inside the network through evolution, NEAT might be used to train a neural network to play the Flappy Bird game.

The network would receive information from the game (such as the position of the bird, how far away the next barrier is, etc.), and it would output bird actions (such as jumping or not jumping). The evolutionary algorithm would rate how well the network performed in the game and use that score to pick the top-performing networks to breed and produce the subsequent generation. With the intention of eventually creating a neural network that can play the Flappy Bird game at a high level, this procedure would be repeated over multiple generations [4]. The major contribution of this study is to understanding the concepts of Entity Size, Generative Index, Reaction Time, and activation functions. To develop an understanding of essential artificial intelligence basic principles and the right neural network process.

1.png

Figure 1. General phases of the Flappy Bird game

The methodology of Flappy Bird is relatively simple (Figure 2). The player controls a bird, which is constantly moving forward, by tapping the screen or pressing a button to make the bird flap its wings and fly upwards. The objective of the game is to navigate the bird through a series of pipes without hitting them. Each time the bird successfully passes through a pipe, the player earns a point. The game ends when the bird collides with a pipe or the ground. Being Precise, we have used a particular configuration locker file, trained weights and configured the NEAT-Algorithm to our needs. This is very simple as all other developers do, but the main structure and framework, aim rather is to prove the NEAT may look like an ancestor to new robust models, but it’s not obsolete [13-16].

2.png

Figure 2. General flowchart of the implemented methodology

The game mechanics of Flappy Bird are designed to be challenging and addictive, with the player needing to have quick reflexes and good timing to navigate the bird through the gaps in the pipes. The game has simple graphics and sound effects, but the difficulty level and the addictive gameplay make it a popular choice among casual gamers.

The methodology of Flappy Bird can be summarized as follows:

Simple game mechanics: The player controls a bird by tapping the screen to make it fly, with the objective of avoiding pipes and earning points.

Challenging gameplay: The game is designed to be difficult, with the player needing to have quick reflexes and good timing to succeed.

Addictive qualities: The game is designed to be addictive, with players wanting to keep playing to improve their score and beat their high score.

Simple graphics and sound effects: The game has basic graphics and sound effects, but they are effective in creating an immersive gaming experience.

Without explicitly constructing the network architecture or manually adjusting the connections and weights, NEAT enables the training of neural networks to play games. Instead, the evolutionary algorithm takes care of these tasks automatically, letting the network experiment with the game and learn how to play it. Following are the steps we take to initialize and set up the environment.

3.1 Initialization

The popular Flappy Bird game was developed; it contained a few obstacles that the user's taps were supposed to help the flying bird navigate through. By teaching an AI Engine to perform a classical masterwork, we give a thorough analytical analysis of AI process. In this instance, we have an initial entity to comprehend the methodology and procedure. Let's say that thing is a Bird_Y (Figure 3) in an Environment (Ĵ).

3.png

Figure 3. Flappy Bird representation

We used the classical method of giving coordinates to a particular engine X, in this case cored upon NEAT. Keep in mind that these heights are not always constant. In order for the engine to relate to each coordinate of the impediments, we train it to reproduce itself with every data coordinate.

The engine employs the function of $\operatorname{Tan} H$, where H is the obstruction's height, and uses it as the activation function. It then calculates the generative index (k) (obstruction generation rate), utilizing both size estimation and randomizing the function of $\operatorname{Tan} H$. The formula can be represented as follows (1):

$\Delta k=\operatorname{Tan} H . S[H+\omega(S)]$     (1)

where, k is the generative index, $\operatorname{Tan} H$ is the function of height and S is the size estimation on past records. ω is the omega of S i.e. factorial value of the size and height. This was the case of height estimation. Now, to detect the obstruction, the engine uses Bird_Y by sending the above activation function to every coordinate and detecting the perfect $\operatorname{Tan} H$ value. In this way, the engine is able to detect the obstruction. Below table (Table 1), shows the ratio of the activation functions with different bird generations. In the classical Flappy Bird game, we have seen that there is no particular end to the game, even anyone may get old playing that [17-19]. To revise here, Flappy Bird was a classical icon, known for it’s 2-D physics and very-minute mechanical_features. The game is very constant as you progress to the never-ending end. During research, we observed that the speed_mechanics remain very common in every progressing stage, but the pole-height dynamics keep on changing, which are very much defined in the algorithms.

Table 1. Ratio Functions with different bird generations

Now, we can see the proof of this being a reinforcement learning method, the results get better with each new generation, but it is crucial to note that the Bird Y:2 has the most challenging environment, which show the gameplay remains balanced at the start and end, with a flux in- the middle, the part where most of the players get eliminated. The flux, too, in pole heights, which creates a very short space for the bird to fly, evident from the last column of the Table 1 above [20].

3.2 Environmental setup: Flappy Bird

The steps that must be taken in order to set up the environment are as follows:

1. Create a development environment: We set up Python and the tools required, such as Pygame and Pyglet, to create the Flappy Bird game and execute the NEAT algorithm.
2. Build the Flappy Bird game: We build up the user input management, visuals, and game logic for the Flappy Bird game. A game creation library like Pygame or Pyglet was used for this.
3. Define the neural network's inputs and outputs: The input and output parameters for the neural network that manages the Flappy Bird game must be chosen. The position of the bird, the distance between obstacles, and other information are inputs. The output was a binary value that indicated whether or not the bird should jump.
4. Implement the NEAT algorithm: The NEAT algorithm, which entails generating a population of neural networks with various topologies, assessing their performance, choosing the best-performing networks to breed and generate the following generation, and repeating this process over a number of generations, implemented in Python.
5. Train the neural network: After implementing the NEAT method, we must train the neural network by playing the Flappy Bird game and modifying the connections and weights within the network using the NEAT algorithm. This can be accomplished by repeatedly running the game, feeding the neural network data from the game, and then assessing and enhancing the network's performance using the NEAT algorithm.

Once the neural network has been trained, we can test its effectiveness by running the Flappy Bird game and observing how well it functions. To enhance the performance of the network, we might have to tweak the NEAT settings or other factors.

3.3 Neural network: Flappy Bird

These general procedures must be followed in order to create a neural network for NEAT-Flappy Bird:

1. Define the network's inputs and outputs: The input and output parameters for the neural network that will operate the Flappy Bird game needed to be chosen. The position of the bird, the separation between obstacles, and other information are inputs.
2. Create a population of neural networks: Using the specified inputs and outputs as the network's input and output layers, we had to build a population of neural networks with various topologies. The number of hidden layers and the number of neurons in each layer could be included in the network structure.
3. Initialize the weights and biases of the networks: Because these values are altered throughout training, we had to initialize the weights and biases of the networks randomly.
4. Training the neural networks: To train the neural networks, we had to play the Flappy Bird game while modifying the connections and weights in the network using the NEAT algorithm. This can be accomplished by repeatedly running the game, feeding the neural network data from the game, and then assessing and enhancing the network's performance using the NEAT algorithm.

The NEAT method was used to pick the top-performing networks after the neural networks had been trained in order to breed and create the following generation of networks. Using the NEAT method, we must repeatedly train the neural networks across a number of generations in order to assess and enhance their performance. Since, this is a Reinforcement-Learning based method, repetitive analysis and feedforward_configurations are to be made. Furthermore, we did not extend the cycle of 3-repetitive conjunctions in the network_modification process. Yes, it is a hectic process during the initial initialization process, and weight collection, but an expert would know that no generic-process under the umbrella of Reinforcement-Learning is straight-forward and uni-processed [21]. Also, it is essentially a problematic situation when you deal with both NEAT, and NN hand-in-hand, as there are certain weight-cycles to go through in the process. Furthermore, the newer process of gradient-boosting has a reduced number of cycles to go through. Hereafter, NEAT and NN would have got a very less number of retries, if the quality of data was greater. Further, CV has got a complete lead here due to its procession on a certain caffe_model, which helps it to go from the second or even very_first try of the program [22-24].

NEAT, although being an outmoded NN method, provided a 98% accurate and equivalent outcome when compared to CV-AI. The output tables (Table 2 and Table 3) below demonstrate the same.

Table 2. Neat performance

Table 3. Generic CV model Performance

The figure displayed as Figure 6 represents a graphical representation of the performance of NEAT and Generic models. While CV-based models operate more quickly and efficiently in real-time, NEAT-based models offer greater accuracy and stability in the flow of operations. However, it is also possible to train NEAT models in real-time and achieve good performance, as long as the appropriate constraints are put in place.

The processing and use functions of the model can also have a significant impact on its performance and the level of difficulty in managing the project. For example, the mathematical activation function used in the model can influence its performance. In computer vision applications, the Tan H activation function can be replaced by Sigmoid to improve performance.

There are several significant differences between NEAT-based and CV-based Flappy Bird AI models, including differences in complexity of development. NEAT-based models rely on the evolution of neural networks to improve their performance over time, while CV-based models typically use pre-trained models and algorithms to recognize patterns and make decisions.

A genuine note for the readers, we are not trying to completely defenestrate the Generic-CV model, instead we are trying to show our panglossian attitude towards the NEAT-module.  There are a lot of key factors that have an edge over the traditional RL-based NEAT module. Baud_loss while structuring is one, and many others have been mentioned further. We have had common arguments on the time taken by NEAT-module portray the data-based results, which is often considered illogical by many experienced ML Engineers, but it is grave to note, that the NGS- Framework (UNIX) is still a main project operating on the NEAT- module. When it comes to Pole-balancing, nothing can beat NEAT-module. Automated Gas-Pipelines were a sharp architecture built with the oldest of oldest versions of these algorithms. Yes, there are methods like Gradient-Boosting, which have a handsome edge over this algorithm, but NEAT is the obvious frontline on minute-details based projects. The other most challenging part is the slow convergence to optimal results, especially in highly confusing environments, like space-tech, or even generic astronomy, but the competence of this module with (algorithms like A3C and DDPG) has proved its worth. Furthermore, the modules that today are compared with NEAT, are somewhat built with the methods that pre-existed in NEAT. Like, generic_convergence and diverse_framworks. The CV model has inherited the Caffe-byte conversion from the NEAT Architecture.

The graphical representation of the performance of NEAT and Generic models, shown in Figure 5, provides a visual representation of how these two models compare in terms of their performance. The figure shows how the two models perform across different input rates on serial_baud, with the two best results for each model highlighted.

Overall, this statement highlights the importance of understanding the differences between different types of AI models and the factors that can impact their performance. It suggests that while NEAT models may require more complex development and training, they can offer greater accuracy and stability in certain applications. However, the choice of model and processing functions should be carefully considered based on the specific requirements and constraints of the project at hand. Now, NEAT is a module that was introduced very early in this rapidly over-expanding field of machine learning, and is often considered as the initial-zone for simulative engines and complex-mathematical procedures. It is grave to consider other overall factors that are a crucial part of this evaluation of NEAT’s legibility and true for real time scenarios in today’s world. We’ll be now, taking a brief look at some other key factors that stay in the defense of NEAT’s compatibility, and some others that oppose the modus-operandi of this veteran simulation module. It is very obvious that Generic-CV has some beneficial improvements, and will definitely be able to tackle some factors against NEAT. The factors that we’ll consider in this part of the evaluation are: {Time Complexity o(n), Time-to-Time coordination with the  bird (w), and Generic Tracing (R)}.  The main difference where the efficiency factor comes into play is the use of .pickle file extension which is very crucial while operating on NEAT. The basic purpose for this, is to serialize Python Object Structures which refers to the process of converting an object into a byte stream, thus each and every trajectory has to be converted into a stream and transferred to the memory. The CV model has got an advantage, as it operates on real-time graphic-byte-streams. We have discussed the Time Complexity (0(n)) before, and the Computer Vision model has got a clear advantage there. Hereafter, if we check on the Generic Tracing (R) , We can conclude that NEAT-module has to rest down the debate, because there is no model better than CV or OpenCV at capturing real time streams of images (whether in presence of Cudart64_dll or not).  The CV model has got a knack of tracing the object to the best of it’s potential. These factors create a fast-paced environment for the CV-model which is Agathokakological for it, because it can increase it’s efficiency, but compromise the accuracy a bit. Sometimes, the CV model has an edge, where the NEAT-module is not able to compute in a certain heap, or benchmark.

6.png

Figure 6. Performance of NEAT model and Generic CV model

The way the AI analyses the game data is one notable difference. A neural network used by an NEAT-based AI to interpret game data receives input from the game and generates output actions based on this input. Contrarily, a CV-based AI processes game data using computer vision methods, which entails examining the game screen and extracting pertinent data from it. The manner the AI is trained is another distinction. By building a population of neural networks with various topologies and using an assessment function to choose the best-performing networks to breed and produce the following generation, an evolutionary algorithm is used to train an NEAT-based AI. Contrarily, supervised learning is often used to train CV-based AI. This method entails giving the AI labelled training data and using an optimization algorithm to modify the network weights and biases in order to reduce the error between the expected and actual outputs. The degree of interpretability of the AI's decision-making process is a third distinction. As an NEAT-based AI is trained via an evolutionary algorithm that modifies the connections and weights inside the network rather than providing explicit rules or guidelines for decision-making, it is often less interpretable than a CV-based AI. Contrarily, because CV-based AI is trained via supervised learning and can be made to extract particular traits or patterns from the game screen that are important to the decision-making process, it is frequently easier to interpret.

In summation, the processing of game data, training methods, and interpretability of decision-making processes differ between NEAT-based and CV-based Flappy Bird AIs. The project's particular objectives and limits will determine the optimal method.