P.S. The documentation seems a little bit oudated, so read carefully the homepage for the changelog. E.g. if you want a shaded background you have to use shadetb (or shadelr) instead of shade-tb (shade-lr) as specified in the documentation.

Obtained with the Author Wordle just introduced by SciVerse Scopus.

I was surprised that the first (working) implementation came out only after twenty minutes, using the simple tutorial the author Christian Perone provides in his blog.

Everything starts in this way:

from pyevolve import *
import pylab
import math

Then you define a main function, where I put the data load routine from a .csv file

def main_run():
# Load data from file.csv
myReader = csv.reader(open('filename.csv', 'rb'), delimiter = ',')
for row in myReader:
    # do something

Then with the following simple lines you define a classical GP program setting the maximum trees depth and selecting the fitness function (eval_func in this case):

genome = GTree.GTreeGP()
genome.setParams(max_depth=3, method="ramped")
genome.evaluator.set(eval_func)
ga = GSimpleGA.GSimpleGA(genome)

Then there is the most important part, the definition of terminals and functions:

ga.setParams(gp_terminals = ['x1', 'x2','x3','x4','x5','x6','x7', 
'ephemeral:random.random()'], gp_function_prefix = "gp")

Here I defined ‘x1‘ … ‘x7‘ as , thus I added a constant, a random float between 0 and 1 (you can use any kind of random function within random python package). For the functions is very easy, all the python functions whose name is starting with the specified prefix are considered GP functions (in my case I have gp_add, gp_mul and so on for other arithmetic operators).

Now you can end with the last settings:

ga.setMinimax(Consts.minimaxType["minimize"])
ga.setGenerations(1000)
ga.setMutationRate(0.08)
ga.setCrossoverRate(0.1)
ga.setPopulationSize(2000)
ga.evolve(freq_stats=5)
best = ga.bestIndividual()
best.writeDotImage("tree_pi.jpg")
print best

where you set evolutionary parameters (crossover, mutation etc), statistics console outputs, the plot of the best individuals and also the output to a png file of the tree of the best individual.

Now you can define the GP functions that as stated above whose name starts with ‘gp’:

def gp_add(a, b): return a+b
def gp_sub(a, b): return a-b
def gp_mul(a, b): return a*b

And finally the fitness function:

def eval_func(chromosome):
code_comp = chromosome.getCompiledCode()
err = 0;
for i in xrange(8, len(target)-1):
x1 = target[i-1]
x2 = target[i-2]
# ...
x7 = target[i-7]
 
evaluated     = eval(code_comp)
err += (target[i] - evaluated)
 
return (abs(err))

Here you set as error function the sum of the absolute prediction errors, you ‘compile’ the GP tree as python code and then for all the time series samples (that I defined as a list surprisingly called target) the for loop evaluates the error between target value and obtained value computing in the end the error.

At this point you can run your code and, et voilà, you obtain a predictor for your forecasting problem. Now you can really start to do research getting an accurate predictor tuning the algorithm parameters, selecting the right variables and constant as the GP functions. To get more information about pyevolve check also the specific Google group.

I think that famous conferences (like IEEE ones and GECCO) are becoming just a way to be seen and publish works which otherwise would need at least one year to be published on computer science journals, but the possibility of meet potential collaborators is getting smaller, because these conferences are huge (>600 participants!) with a massive amount of parallel sessions (the last IEEE SSCI I attended started at 8.30 in the morning and there were each day 6-8 parallel sessions, see the conference schedule…). Check the PPSN 2012 website to know the publication deadlines and getting other important information.

Read the interesting editorial appeared on the Communications of ACM with the title “Where have all the workshops gone?” about the workshops disappear (and the north american Dagschull Envy!).

The main problem for MCDM is the necessity of cope with more criteria when ordering and classifying. One possibility is to use all the Pareto theory and apply some algorithms, like Evolutionary Algorithms: niching ones (NPGA, NSGA) or elitist micro-GA and PAES. However, you can try to aggregate the criteria with a linear combination or with a constraint approach: only one objective is optimized and the other ones are used as constraints, as:

The linear combination sounds simple but how to get the best weights? In 70s, Thomas Saaty from Wharton School (UPenn) presented a method to find objectives’ priorities using pairwise comparison (see the original paper). Bonissone, in this clear presentation, explains how to get the weights vector having only pairwise comparisons between objectives (A is times better than B).

Among the cases he presented, there was one about the minimization of uncombusted coal in power plants, minimization of emissions and constraints about load. He used data generated by the real plant, explorating new solution spaces during the night, to train neural networks and using them as models to predict objectives. This approach was tested on a real plant obtaining sensible improvements. One paper about this topic was published in 2006 on Applied Soft Computing (link), but I can suggest the 2009 paper on IEEE Computational Intelligence Magazine to have a wider vision of MDCM (link).