Caught in the Net (Posts about python)

Interpolation using a genetic algorithm

Francesco Mecca — Sun, 15 May 2016 00:00:00 GMT

This weekend I was in Milan to get a visa and I had the opportunity to work with a friend, Michele, on genetic algorithms. It was the first time I dig up in such field and it was very exciting. In this post I want to explain some bits of our work.

A brief introduction to GA

A genetic algorithm is a search/optimization algorithm that uses an heuristic approach to reduce the search space and evolve gradually to a solution.

Population

It is an algorithm that has its root in the theory of natural selectioni by Charles Darwin. The main components of a GA are:

the population, that concentrate all the available solutions at a given time;
the fitness function, that gives an approximation of the quality of the solution codified by a given member of the population.

In a GA the first thing to do is to generate a population.

A population is a group of objects with given attributes, usually a string, and they contains in some form the solution (usually inside a string); the first population is randomly generated and contains a big number of solutions, but not every solution (this is not a bruteforce approach).

After this step the fitness functions evaluates the quality of every solution that a given member carries: the evaluation should be considered from a bottom up point of view.

Reproduction

Now, as in Darwin's theory of evolution, the member of the population are going to "reproduce": two members are going to be coupled to generate a new member of the second generation and every child member will contain a solution that is the product of the original genes of their parent members.

This time the reproduction of the population into a second one is not entirely random. The fitness function gives us an approximation of the quality of every gene that a member carries and by the rule of the "survival by the fittest" the probability that a member is going to reproduce with another one is proportional to the quality of its genes.

When we have a second generation of members we can recur on our GA and generate a third generation. From this point we can recur until we converge to a solution that is common to every member, or at least that is suited to our needs.

Mutation

Actually, in some cases, a mutation function can be added, so that, like in real world, some times the genes are "scrambled" indipendently from the fitness function.

There is more to a GA, for example we could talk about possible ways of storing the genes inside a member or when to use mutation, anyway I want to stop here and continue with an analysis of my problem.

Interpolating a function using a GA

Me and Michele decided to spend some time developing a little python script to explore GA capabilities and we decided to interpolate some points on a cartesian plane.

Our program, that is available here uses a class to define the various members of the population and a string for the genes, a class as well for the points on the plane.

The fitness function is not as precise as it should be because this is only a proof of concept:

.. code:: python

mutationProbability = 0.1
rangeLimit = 5
def fitness(item, pointList, n):
    value = 0
    for p in pointList:
        y = 0
        for i in range(n):
           y += item.gene[i] * pow(p.x, i)
        result = 1 - (abs (p.y - y) / rangeLimit)
        if result < 0:
            result = 0
        value += result
    return value / n

item is just a member of the population, poinList is the list of points and n is the number of points (n - 1 is the grade of the function).

for i in range(n):
    y += item.gene[i] * pow(p.x, i)

this piece of code gives us the value of the function encoded in the genes in the points of pointList;

result = 1 - (abs (p.y - y) / rangeLimit)
    if result < 0:
        result = 0

while here the script stores 1 - the previous result because if the GA has yield a good result there should be distance = 0 from the function evaluated and the points; If this is the case, the fitness function should attribute the highest possible reproduction probability for that member. At the end the fitness function returns the total value over the number of points evaluated.

As you can see this fitness function is by no means an optimal one. The reproduction probability is higher for functions that crosses some points and are really distant from others rather than for functions that are closer to every point but crosses none. Anyway for simple cases the GA yields good results, as an example for points (0 0), (1 4), (2 9) one of the member with the highest reproduction probability has this function in its genes:

-0.0487839869993989 * x^0 + 4.600339125358671 * x^1 + -0.2780958075230644 * x^2

that crosses this points: (0 -0.0488), (1 4.2735), (2 8.0395) given 80 iterations, initial population of 600 members and a two digit approximation.

For a more precise computation a higher population size and a really high number of iterations should be used.

Kyuss Music Player

Francesco Mecca — Sun, 17 Apr 2016 00:00:00 GMT

For a long time I have been using Clementine music player on my workstation. Recently I reinstalled Gentoo on my desktop and I wanted to avoid installing QT libraries of any sort. So I switched to mpd and I have fallen in love with it. It is very flexible, fast and enriched by a lot of community software. For some weeks I used mpc client as my primary client for mpd but I was not satisfied with it. Even though it is pretty minimal but packed with every feature mpd permits, the search feels uncomfortable because is case sensitive and need artist, album, etc. flags before any entry. This is why I have written kpd together with Francesco Gallà

Kyuss Player Client

kpd is an acronym for Kyuss Player Client because we have been listening only to Kyuss while programming this client. We have reimplemented the search functions to suit our habits. No more case sensitive, optional 'artist, album, title' flags. kpd accepts only one string as the search argument and implements optional filter arguments to narrow the search in a grep like way. I welcome you to read the readme in my git to understand how the search works. Anyway in this post I want to explain bits of the code.

Main

The main kpd file invoked when the command is run in the console is kpd.py The most interesting part in this file IMHO is these lines:

.. code:: python

    for el in argsOrder:
        if dictArgs[el] != False:
            client.update_status ()
            methodToCall = getattr (util, el)
            retUtil = methodToCall (client, dictArgs[el], searchRes)

argsOrder is a list of the arguments on the command line in the order the user wrote them. kpd uses a dictionary to store for every argument the corrispective string for the function that will be invoked using getattr. In this way any argument can be added to the main file without writing any other line of code. WE used this method to avoid using switch alike solutions.

Util

The util.py source file is a pretty easy source file to read. It contains every function that can be invoked by command line arguments. Every function has the same 'prototypes' so that they can be called using the method explained above. To implement no-output and output function I have used a class: to suppress the output on the console the program assign to sys.stdout a dummy class that save the original stdout on a variable and replaces write and flush functions so that they are just pass. and no output is written. To permit output after suppression the program just reassing the original value to sys.stdout.

Database Search

In MPDdatabase.py we have written the search functions. Originally we intended to just read and import in a dictionary the whole mpd database that is stored compressed in the home directory. This list of dictionaries stores every entry related to the song and if any of them matches the search string or the filter string (considering also flags if any) the related song is printed on the output and saved in a list so it can be added by the add function. This approach result very efficent in term of precision but it lacked speed. For a database of about 77 thousand songs (about 550k lines) a search query could last almost 2 seconds. To improve the speed of the search we used the pickle module. The pickle module allows kpd to dump the data structure used to store the database in memory on a file that can be read easily by using the pickle.load function. In this way the search lasts about 40 milliseconds on the same database that wastes about 16MiB of memory on disk.

Conclusion

This was really fun. It was our first hand on python project and the first real program we have written since we started learning programming at our university. I discovered that programming allows me to relax and that is really cool to have custom software for activities you do every day. The source for our program is stored in my git here and you are free to modify it.

The Buridan's donkey in python

Francesco Mecca — Sat, 02 Apr 2016 00:00:00 GMT

During the final weeks of my exam session I started reading a bit about python 3 using an excellent book: Dive into Python. When I noted that python uses the Mersenne Twister PRNG as well I decided to write another version of my Buridan's donkey program.

.. code:: python

    import random, sys

    if __name__ == '__main__':
        args = list()
        if not sys.stdin.isatty():
            for line in sys.stdin:
                if line[-1] is '\n':
                    line = line[:-1]
                args.append(line)
        else:
            args = sys.argv[1:]
        argRange = len(args)
        for i in range(argRange):
            print(str(i+1) + '.', args.pop(random.randrange(0, len(args))))

This script works in a different way than the one in c++. Rather than shuffling a list made by the entries in the arguments, it pops randomly one entry from the list till the list is empty.

Not satisfied enough, I wrote also a telegram bot using the telebot library that works as the script above but inside the telegram app. The bot can be added to your contact list by simply searching for @duridan_donkey_bot (yes, a typo!)

All the code is opensource and can be found on my github page.

Francesco Mecca