fittest | fittest is a tool to create black box tests | Unit Testing library

As mentioned in the comment of @Andy Turner, the error was caused by the GoogleSignIn.getLastSignedInAccount(this) call that returned 'null'.

The reason for this was a mismatch between SHA1 Certificate Fingerprints in the OAuth configuration in the google cloud console and the one used to sign the app by Android Studio. This was caused by compiling the app in two different installations of Android Studio.

The issue was solved by adding a second OAuth 2.0-Client-ID with the certificate of the second Android Studio installation.

If you take a long time to getFitness(), you should minimize its call.

Sorry to tell you that this approach just isn't going to work. Remember that neural networks are typically built out of doing a matrix multiply and then max with 0 (this is called RELU), so basically linear at each layer with a cutoff (and no, picking a different activation like sigmoid is not going to help). You want the network to produce >.5, <.5, >.5, <.5, ... 25 times. Imagine what it would take to build that out of RELU pieces. You would at the very least need a network that is ~25 layers deep, and NEAT is just not going to produce a network that large without consistent incremental progress in the evolution. You are in good company though, what you are doing is equivalent to learning the modulo operator, which has been studied for many years. Here is one post that succeeds, though not using NEAT. Keras: Making a neural network to find a number's modulus

The only real progress you could make with NEAT is to give the network many more features as inputs, e.g. give it x%2 as input and it will learn quickly, though this is obviously 'cheating'.

Here is a function called crossover that takes two parents and a crossover point. The parents should be lists of integers of the same length. The crossover point is the point before which genes get exchanged, as defined in the article that you linked to. It returns the two offspring of the parents.

Genetic algorithms, by design, eliminate the weakest solutions in the set by simply not including their genes in future generations.

Abstract: imagine that the algorithm is choosing which solutions are to be chosen, combined, and mutated for the next generation. Each solution is put on a dart board, but the better solutions take up more space on the dart board, so when the algorithm throws a dart, it is more likely to hit a more fit solution. In fact, it may even hit the same solution more than once.

Once it has its' solution set from the dart board (generally same population size as your original set, but probably contains duplicates from multiple darts hitting the same solution), you take this set, and "mutate" them by randomly switching parts of the solution. You then can "mate" solutions, in a very sexy process where you take parts of random solutions in the new generations, and combine them to form a final generation set.

This process is then repeated.

What happens to the solutions whom no dart hit? It depends entirely on your language and data structures, but they are probably objects that just get garbage collected.

Take this as an example:

I recommend to make Population a generator function. See The Python yield keyword explained:

If you "found" this code (most probably on the internet?) then the one who posted this had a libs folder in his machine, with a GeneticAlgorhythm.py module in it, so you either find this GeneticAlgorhythm module, or you won't be able to run this code successfully.

When you see, in python from baz.bar import Foo, Python is going to look for the bar module into the baz folder, and import class Foo from it. So you need to have baz module on your PC, or else that error will appear

To get minimal amounts of 1 we need each 1 to handle as many 0 as possible which means we need to repeat 010 maximal amount of times. So we can start replacing zeroes with 010 from left