Difference between revisions of "Evoptool: Evolutionary Optimization Tool"

From AIRWiki
Jump to: navigation, search
(Project profile)
Line 212: Line 212:
 
* [http://www.gnuplot.info/ Gnuplot Utility]
 
* [http://www.gnuplot.info/ Gnuplot Utility]
 
* [http://www.cplusplus.com/reference/ C++ Library reference]
 
* [http://www.cplusplus.com/reference/ C++ Library reference]
 +
 +
== ''ToDo List (only for developers)''==
 +
> -la cartella bin andrebbe vuota, perché ogni make clean la .svuota. solo
 +
> che dentro ci sono cose che servono.. ora ci penso a come fare.. forse
 +
> andrebbero messe in un'altra directory le cose che ci sono dentro. da
 +
> valutare...
 +
Correggimi se sbaglio, prima di fare il checkout sarebbe meglio fare un make clean, giusto? gli altri file tipo i dati si sarebbe carino e più ordinato fare un insieme di cartelle separate
 +
 +
 +
 +
> -nel makefile di common ho dovuto commentare un po' di cose perché non
 +
> compilava correttamente
 +
boh.. io avevo perso tutto ad inzio giugno perchè mi si era bruciato l'harddisk.. cambiato harddisk, ubuntu nuova e compilava correttamente. considera che evoptool l'ho riscaricato da giugno una settimana fa..
 +
 +
> -il make file di gui ora è come gli altri standard dei vari moduli. era
 +
> una versione vecchia e aveva dentro un po' troppe cose inutili
 +
questo me l'aveva fatto notare un mio amico smanettone del C, ma anche qui devo impratichirmi con i makefile.
 +
 +
> -quando lanci il programma, a te gnuplot si lamenta così:
 +
> "Could not find/open font when opening font "arial", using internal
 +
> non-scalable font"? credo sia un problema mio..
 +
credo sia un problema tuo, forse devi installare qualche font associato a gnuplot o direttamente del sistema.
 +
 +
> -quando esco dal programma, a me l'applicazione va in crash. e "Bug
 +
> Buddy" di gnome si lamenta.. a te si presenta il problema? forse è un
 +
> problema di gcc? con che gcc hai compilato tu?
 +
Al momento sto usando gcc 4.3.3, effettivamente mi pareva che nel chiudere l'app lanciava un segmentation fault, probabilmente è qualcosa nel distruttore della classe GUI. Se riesco cerco di risolvere
 +
 +
> -il file sBOA non va in bin, ma va ricompilato dai sorgenti la prima
 +
> volta, altrimenti ci possono essere problemi di librerie. io farei un
 +
> modulo (o una dir) nella root del progetto dove mettere tutti si
 +
> software esterni, al posto di avere una sotto directory in gui
 +
> (aggiungere un readme che indica di ricompilare boa al primo checkout)
 +
sarebbe l'ideale, io boa non l'ho mai toccato ma comunque andrebbe sistemato.. magari anche per il kill trovare il modo per far comunicare un minimo i due programmi..
 +
 +
> -perché c'è un controllo che se imposto a 30 il problem size me lo fa
 +
> passare a 50?
 +
cavolatina, semplicemente con glade quando metti gli spinbutton ti chiede un range di valori ed è stato piuttosto casuale.. lo abbasso a 10, che dici? dimmi tu..
 +
 +
> -credo ci sia un problema con la visualizzazione dei dati. quando lancio
 +
> sBOA con i parametri: trap5, popsize 3300, size 60, l'agoritmo converge
 +
> all'ottimo globale, ma la visualizzazione del grafico non va al 100%. i
 +
> valori che visualizzi sono rapportati a 100% come per gli altri algoritmi?
 +
> esempio: se lanci insieme anche DEUMd, questo si ferma a 80, e sembra
 +
> funzionare meglio di sBOA..
 +
questo era sempre il discorso delle fitness non normalizzate allo stesso modo nei due programmi, non ricordo se trap5 era già presente in boa o l'avevamo aggiunto noi. bisognerebbe ricontrollare tutte le fitness di boa e controllare che siano normalizzate tra 0-100
 +
 +
 +
> -c'è il problema noto che non riusciamo a stoppare sBOA. magari lo stop
 +
> potrebbe essere equivalente ad un kill del processo che abbiamo lanciato..
 +
qui il problema più del fare una kill è che bisognerebbe trattare boa in maniera diversa dagli altri algoritmi. Essendo tutto standardizzato bisognerebbe gestirlo in maniera adhoc.. ci avevo già pensato ai tempi, ma non avevo trovato una soluzione semplici.. cose macchinose.
 +
 +
 +
> -mi confermi che manca una implentazione del problema spin glon s, su cui
 +
> testare l'efficacia di isDEUM?
 +
si, appunto ci sto lavorando in questi giorni ed era l'oggetto di questa mail anche perchè volevo capire quale era il problema di isdeum (implementazione oppure problema da risolvere).
 +
 +
> -domanda: si possono impostare dei valori di default diversi per popsize
 +
> per ogni algoritmo?
 +
si si tranquillamente, ogni algoritmo selezionato ha il suo pannello dei parametri e sono indipendenti tra loro. L'unica cosa comune tra i diversi algoritmi lanciati è appunto l'istanza del problema da risolvere.
 +
 +
 +
> -non ho capito il funzionamento del TAB2 e del TAB3.. non mi
 +
> visualizzano i grafici. credo di non aver capito io come funziona, ma
 +
> non vedo nessun output
 +
tranquillo, al momento non fanno nulla. Solamente quando ho fatto l'interfaccia l'avevo fatta predisposta per la visualzizazione di diversi grafici (pensando al futuro :-))ma al momento usiamo solo la fitness media.

Revision as of 12:11, 4 August 2009

Project profile

Name: evoptool: Evolutive Optimization Tool.
Field: Combining Estimation of Distribution Algorithms and other Evolutionary techniques

for combinatorial optimization.

People involved: Matteo Matteucci - matteucc@elet.polimi.it

Luigi Malagò - malago@elet.polimi.it

Gabriele Valentini - gabriele.valentini@mail.polimi.it

Short Description

The project focus on the study, implementation, comparison and analysis of different algorithms for combinatorial optimization using techniques and algorithms proposed in Evolutionary Computation. In particular we are interested in the study of Estimation of Distribution Algorithms, a recent meta-heuristic, often presented as an evolution of Genetic Algorithms, where classical crossover and mutation operators, used in genetic algorithms, are replaced with operators that come from statistics, such as sampling and estimation. The focus will be on the implementation of new hybrid algorithms able to combine estimation of distribution algorithms with different approaches available in the evolutionary computation literature, such as genetic algorithms and evolutionary strategies, together with other local search techniques.

User Manual

Algorthms

This section have the purpose to show the set of algorithms implemented inside evoptool. These algorithms belong to different classes, and they perfom different operations. In the following lines are presented the theoretical bases for better undestand the use of evoptool.

  • Genetic Algorithm (GA). Is a search technique used in computing to find exact or approximate solutions to optimization and search problems. They grow a population of abstract representations (chromosomes or genotype) of candidate solutions (individuals or phenotypes) to an optimization problem evolves toward better solutions. In this tool, solutions are represented as binary strings of 0s and 1s, but other encodings are also possible. The evolution usually starts from a population of randomly generated individuals and happens in several generations (selection, crossover, mutation). The new population is then used in the next iteration of the algorithm. Commonly, the algorithm terminates when either a maximum number of generations has been produced, or a satisfactory fitness level has been reached for the population. Nowaday, there are the following GA implemented inside evoptool:
    • SGA (Simple Genetic Algorithm). A selection operator is applied to the population and two random recombinator operators called crossover and mutation are applied to the selected population in order to improve the population. SGA uses a truncation selection with a fixed percentage. The variation operators used are Uniform crossover and Bit-Flip mutation.
      • SGA with Binary Tournment.
      • SGA with Population Wise Uniform Crossover.
  • Estimation Distribution Algorithm (EDA). Is powerful population-based searcher where the variation operations traditionally implemented via crossover and mutation in EAs are replaced by the process of random sampling from a probability distribution. The distribution is modified generation after generation, using information obtained from the fitter individuals in the population (estimation). The objective of these changes in the distribution is to increase the probability of generating individuals with high fitness. In our tool there are several EDA implemented such:
    • cGA (Compact Genetic Algorithm). It initialize a vector of probabilities where each component follows a Bernoulli distribution with parameter 0.5. Next, two individuals are generated randomly from this vector of probabilities. After the individuals are evaluated, a competion between then is carried out. The competion is held at level of each of the unidimensional variables, in such a way that if for the ith position the conquiring individual take a value different from the loser, the ith component of the vector of probabilities increases its value.
    • PBIL (Population Based Incremental Learning). It maintains unconditional probabilities and no interparameter dependencies are modeled. A vector, P, specifies the probability of generating a 1 in each bit position. Initially, all values in P are set to 0.5. A number of solution vectors are generated by stochastically sampling P; each bitis sampled independently of all the others. The probability vector is then moved towards the generated solution vector with the highest evaluation.
    • UMDA (Univariate Marginal Distribution Algorithm). At each generation, it estimate the joint probability distribution model of the selected individual by factorize it as product of indipendent univariate marginal distributions. Each univariate marginal distribution is estimated from marginal frequency.
    • MIMIC (Mutual Information Maximizing Input Clustering). It attempts to communicate information about the cost function obtained from one iteration of the search to later iterations of the search directly. There are two main components of MIMIC: first, a randomized optimization algorithm that samples from those regions of the input space most likely to contain the maximum; second, an effective density estimator that can be used to capture a wide variety of structure on the input space, and that build a Markov Chain in order to represents the bivariate structure.
    • COMIT (Combining Optimizers with Mutual Information Trees). It gains most of the benefits of modeling the dependencies in the search space at a significantly reduced computational cost. COMIT starts by estimating a probabilistic model of the population, than uses the model to stochastically generate new solutions, it selects the fittest solutions and perfom a local fast-search initialized with these solutions.
      • COMIT with HillClimbing as fast-search.
      • COMIT with PBIL as fast-search.
    • DEUM (Distribution Estimation Using Markov Random Field). DEUM uses MRF approach to estimate and sample the probability distribution using a fitness modelling approach to estimate the MRF parameters. This version of DEUM is an univariate model of probability distribution. This allows to completely eliminate the structure learning task.
      • DEUM with probability vector. It uses the estimated parameters of MRF for update the probability vector, generation by generation.
      • DEUM with direct sampling from Gibbs distribution. It uses the estimated parameters of MFR for directly calcutate the probability of each bit to be 1 or 0.
    • Is-DEUM (Ising model DEUM). It is an evolution from the univariate DEUM to a bivariate version. This algorithm has been defined for solve the Ising Sping Glass problem, and therefore it use a grid structure to model the interactions between each variables of a solution.
      • Is-DEUM with a Metropolis sampler.
      • Is-DEUM with a Gibbs sampler.
    • sBOA (Simple Bayesian Optimization Algorithm). It is a multivariate EDA that uses the Bayesian Dirichlet equivalence metric to measure the goodness of each structure. The search used is a greedy search and it starts in each generation from scratch. In order to reduce the cardinality of the search space the constraint that each node in the Bayesian network as at most k parents is assumed.
  • Genetic Estimation Distribution Algorithm (GEDA). This class of Evolute Algorithms is a new proposal class, where genetic variation operations such mutation and crossover are applied to a probabilistic model of the population, rather than directly to an individual of the population. Each generation of a GEDA is composed by estimation of population distribution, variation of the probabilistic model, and sampling from the variated model.
    • gcGA.
  • Operative Reaserch classical algorithms (OR). It is distinguished by its frequent use to examine an entire management information system, rather than concentrating only on specific elements. An operations researcher faced with a new problem is expected to determine which techniques are most appropriate given the nature of the system, the goals for improvement, and constraints on time and computing power. For this and other reasons, the human element of OR is vital. Like any other tools, OR techniques cannot solve problems by themselves.
    • Pseudo Boolean Linear Programming.

Optimization Problems

An optimization problem is defined by a specified problem space X, an objective functions F , a search space G, a set of search operations A. Specifying the elements of this tuple is the most important prerequisite for any experiment. The problem space X is the space of all possible solutions canditates, in our case is defined by every combinations of a fixed lengh bit string. The objective functions F (fitness) measure the utility of a solution. As convention, we decide that every objective function return a real number between in the [0,100] set, and if nothing else is stated, maximization is assumed. The search space G is the space of elements where the search operations are applied. For evoptool is defined by the individual lenght (size). The search operations A are all the operations used for perform the search, and such we compare several algorthms a time, they are defined by the particular algorthm used.


Inside evoptool, is possible to choose between several different Objective Functions and customize a proper Optimization Problem setting the individual size and choosing a set of Algorithms to compare. The following list contains the Objective Functions implemented for the moment.

  • AltBits.
  • One Max and One Zero Max. The task in the OneMax problem is to find a binary string of length n consisting of all ones. The search and problem space are both the fixed-length bit strings G = X = Bn. Each gene (bit) has two alleles 0 and 1 which also contribute exactly this value to the total fitness.
  • BinVal. It is something like a perverted version of the OneMax problem, with the objective function defined as the real value of the binary string. Since the bit at index i has a higher contribution to the fitness than all other bit at higher indices together, the comparison between two solution candidates x1 and x2 is won by the

lexicographically bigger one. We can expect that the bits with high contribution (high salience) will converge quickly whereas the other genes with lower salience are only pressured by selection when all others have already been fully converged.

  • F3d Deceptive.
    • F3d Deceptive Bipolar.
    • F3d Deceptive Ovelapping.
  • Four and Six Peaks. This Objective Function have some global optima wich are isolated, and therefore are difficult to find. It also have some local optima which are easy to get and therefore the search algorithms tend to converge on local optima.
  • Trap5. Subjected to maximization based on the Hamming distance to a pre-defined global optimum X' . They build a second, local optimum in form of a hill with a gradient pointing away from the global optimum. This trap is specified with two values, b and r, where b corresponds to the width of the attractive basins (in our case b = 5)and r to their relative importance.
  • Quadratic.
  • Sat Lib.
  • SumVal.
  • Royal Road.
  • Liepins Vose Fully Deceptive.

Graphic User Interface

The graphic user interface of evoptool is quite intuitive. The user can easily customize his own experiment, and visualize the results graph. In the next rows there are shortly described the GUI componets and their use.

Evoptool running on Ubuntu 9.04.
  1. Control Buttons. There are three control buttons which can be used to start or stop the execution of an experitment, and to force the update of the graphs.
  2. Objective Function Settings. This part of the toolbar allows the customization of the Objective Problem. It is possible to select an objective function type and fix the individual size as number of bits.
  3. Average Mode Setting. Pushing this toggled button it is possible to enable Average Test Mode. In this mode, evoptool will run a difined number of algortihms for each selected one in the Algorithm Panel, and it will perform the average of the different executions of the same algorithm. This option is usefull to show the average behavior of searchers.
  4. Algorithms Panel. This panel allows to select a set of algorithms to compare in a particular execution. It is subdivided in four parts, in order to classify algorithms for belonging kind. Next, is possible to customize the parameters of each selected algorithm.
  5. Result Tabs. This tabs show the result graphics of the a test execution in real time mode. At this time, only the average fitness graph is implemented in evoptool, but new graphs can be easily added in future.
  6. Log Monitor. This monitor keep the user informed about the execution status and several others information such warnings or errors.

Video Example of Use

In this short video is briefly presented an example of use of evoptool. It starts by configuring the Optimization Problem to solve, next select a set of algortihms to compare and finally is showed the execution of a test.

Command Line

Evoptool is also powered by a command line interface, so when the GUI is not needed and can be an unusefull weight, it is possible to escape it and run the software just typing a command inside a terminal such bash or dash.


Commands

  • --help (-h). This command print at video usefull information about evoptool commands and their use.
  • --version (-v). This command print at video information about currently version of the software and others informations such Copyright or link to the evoptool web page.
  • --nogui [CONF_FILE] (-n). This is the more usefull command, such it allows to run evoptool from command line and to achieve the results as an image graph or, for more complex purposes, as data files. This command need only of one parameter that specify the CONFIGURATION FILE for the execution. The configuration file parameter need to be specified with a proper PATH if, and only if, its position differs from the program executable folder. In the next image is possible to view the output generated from an execution of a test from command line.
Evoptool running from command line

Configuration File

In order to run evoptool from command line, is needed a proper configuration file that define all the contraints and settings for that particulat test execution. A default configuration file can be found in the folder ../evoptool/trunk/gui/bin/confi.evoptool, and the user is free to customize it or to create a different file in a different position and specify the entire PATH before run evoptool. The configuration file is quite intuitive, and the default file presents several usuful information about the contents and how to modify it. It is subdivided in three main section, each of them define the behavior of a particular component.

  • General Settings. Allows to specify if the execution of a test have to be a normal one (Single Run Mode), or an average execution (Multi Run Mode). In the last case, the parameter N_ALGO define the number of execution of an algorithm on that perform the average.
  • Objective Function.Allows to specify which is the Objective Function for this test execution and to define the needed parameters as the individual size or others.
  • Algorithms. Allows to define a set of algorithms to run, and to specify their parameters individually.

Some usefull information on how to customize the configuration file are listed in the next rows:

  • Comment or uncomment lines with a simbol '#' for customize the configuration.
  • Mandatory sections are signaled with a simbol '*', other sections can be deleted.
  • Uneeded parameters must be commented!
  • Values must be between square braces.
  • Order of parameters inside sections is mandatory!
  • There must be the end of file delimiter at last line.

Documentation

Evoptool is a software with the purpose to compare the performance of several different algorithms from the Evolutive family and, for obvious reasons, with some algorithms from the classical Operation Research family. Evoptool is written in C++ for the GNU/Linux platform and it exploit the Gtk libraries (in this case gtkmm libraries) and GNUplot utility. Inside this tool there are several implemented algorithms and some wrapped ones from already existing applications.

Evoptool running on Ubuntu 9.04.

Software Modules

Evoptool is made up of several different modules (or libraries). This architecture make easy to organize files and better understanding how the application work.

  • common - It contains commons classes and ancestors for the algorithm modules and for the optimization function module.
  • ga - It contains the implementation of several Genetic Algorithms.
  • eda - It contains the implementation of several Estimation Distribution Algorithms.
  • geda - It contains the implementation of several gEDAs.
  • or - It contains the implementation of some algorithms from the classical Operation Research.
  • opt-pbl - It contains the implementation of several objective functions (fitness), that represents different problem instances.
  • gui - This module is the main one, it contains all the classes for manage GUI (algorithm decorators). From the other side it implements the multithread mechanism under the GUI, and last but not list it contains the wrapped applications and take care about wrapping.
  • misc - It contains general utility classes such rondom seed geerator.

Hierarchies

This section have the purpose to show some structures internal to evoptool implementation. In particular there are presented the main hierarchies of this software, so, future developers will be facilitated during the development of new componets.


Algorithms Hierarchy

Algorithms Hierarchy

Every algorithm implemented inside evoptool inherits from the abstract class Algorithm. This defines every common attributes and functions, and it is an hight level of abstraction for an algorithm. Next, the others abstract classes GA, EDA, gEDA defines and some times implements common attributes and functions for each category of algorithm, in order to generalize more possible their own concepts. Finally every concrete algorithm will be inherits from one of those last abstract class, and will be a complete implementation of a particular kind of searcher.

Decorators Hierarchy

Algorithm Decorators Hierarchy

Decorators are a very useufull and versatile objects. They allow to easily integrate a new algorithm in the graphic user interface. The abstract class AlgorithmDecorator define some functons that every concrete decorator have to implement. In addiction, it provides the function addParameter that allows a fast customization of each concrete decorator. Finally, a decorator can be viewed as a Wrapper for that algorithms that aren't directly implemented inside evoptool such sBOA.

Objective Functions Hierarchy

Objective Functions Hierarchy

This hierarchy define the structure of Objective Functions. As we can see, it is a quite simple architecture. Every objective functionions inherits from the abstract class ObjectiveFunction, that defines an abstract function f that represents the fitness function. Finally every concrete objective function have to implements this function as specified from the Optimization Problem.


How To Add New Features

Along the next sections will be presented some procedures to follow in order to add new features and components to evoptool. Those instructions are usefull to avoid common errors or to forget some parts of the implementation.

Add an Algorithm

Adding a new algorithm is really an easy task to do. The next lines will show the steps to follow in order to do it. As convenience, we will refere to a generic NewAlgorithm and it will be an algorithm of the category SomeGenetic.

  1. Create files. Create the files NewAlgorithm.h and NewAlgorithm.cpp inside the ../evoptool/trunk/somegenetic/src/ folder.
  2. Fill files. Every algorithm must inherits from the abstract class Algorithm, or from one of its abstract or concrete implementation. Such it have to be a concrete class, it must implments every abstract function inherited from its superclass.
  3. Create Decorator. See next section.
  4. Update Configuration Parser. See proper section.

Add a Decorator

In the following lines there are showed the steps to follow in order to add a new algorithm decorator to the grafic user interface. Here, we suppose to add a decorator called SomeAlgoDecorator for convenience, but obviously these instructions are valid for every decorator.

  1. Create files. Create the files SomeAlgoDecorator.h and SomeAlgoDecorator.cpp inside the ../evoptool/trunk/gui/src/ folder.
  2. Fill files. Every decorator must inherits from the abstract class AlgorithmDecorator, and must provides a concrete implementation of the abstract function:
    • Solver* newInstance(...)
    • MultiSolver* newInstance(...)
    • string plotProperties(...)
    • void initContent(...)
  3. Configure headers. Add the SomeAlgoDecorator.h to AlgorithmDecorators.h (note the 's'!) that is placed in the ../evoptool/trunk/gui/src/ folder. This will avoid to include a long list of decorator headers to the main GUI class.
  4. Add decorator to GUI. In order to concretly add the decorator to the GUI, is needed to modify the GUI.cpp class, adding proper code lines to the initAlgorithmDecorators function.

Update Configuration Parser

In order to add a new algorithm in the command line mode, it is need to modify and update the configuration parser, and to perfom other few task. As previous sections, we want to add a generic SomeAlgorithm to the Configuration Parser.


  1. Configure headers. Be sure that the file SomeAlgorithm.h is added to the header Algorithms.h (note the 's'!) that is placed in the ../evoptool/trunk/gui/src/ folder. This will avoid to include a long list of headers.
  2. Modify Configuration File. Add a new algorithm section to the end of the configuration file. Be sure to fix for that algorithm a proper free identification number. The section must contains every parameters needed by the algorithm.
  3. Update Configuration Parser. This task need to update the function parseAlgorithm of the file ConfParser.cpp placed in the ../evoptool/trunk/gui/src/ folder. Look that, such we can run evoptool in different run modes, there are two different implementation of this function that have a different return object. Remember to update both the implementation!
    1. Add a new case block to the switch/case structure. Be sure to use as case label the same number used before in the configuration file.
    2. Fill the case block with the code for parse the algorithm parameters. Parse every parameter using the just implemented functions. This will avoid to make errors and to spend a lot of time.

Add an Objective Function

This section will lists all the steps to follow in order to add a new objective function, and so add a new optimization problem, to evoptool. Here, we assume for convenience that the objective function to add is called SomeObjFun.

  1. Create files. Create the files SomeObjFun.h and SomeObjFun.cpp inside the ../evoptool/trunk/opt-pbl/src/ folder.
  2. Fill files. Every objective function must inherits from the abstract class ObjectiveFunction, or from one of its concrete implementation. It must implements or overwrites the abstract function f (fitness) inherited from its superclass.
  3. Configure headers. Add the SomeObjFun.h to ObjectiveFunctions.h (note the 's'!) that is placed in the ../evoptool/trunk/gui/src/ folder. This will avoid to include a long list of headers to the main GUI class.
  4. Update Enumeration. Add a new value for the enum GUI::ObjFunctions defined in the GUI header file. The header GUI.h can be found in the ../evoptool/trunk/gui/src/ folder.
  5. Update GUI. In order to link the just created fitness function with the grafic user interface it is needed to modify the GUI.cpp file.
    • getSelectedObjectiveFunction function. Add the new component to the switch/case block.
    • initObjList function. Add the new componet to the Gtk::TreeModel object, so it will be showed in the proper selection menu.
  6. Update Configuration Parser. This is a quite simple task to do, just look to the code!

Usefull Links

ToDo List (only for developers)

> -la cartella bin andrebbe vuota, perché ogni make clean la .svuota. solo > che dentro ci sono cose che servono.. ora ci penso a come fare.. forse > andrebbero messe in un'altra directory le cose che ci sono dentro. da > valutare... Correggimi se sbaglio, prima di fare il checkout sarebbe meglio fare un make clean, giusto? gli altri file tipo i dati si sarebbe carino e più ordinato fare un insieme di cartelle separate


> -nel makefile di common ho dovuto commentare un po' di cose perché non > compilava correttamente boh.. io avevo perso tutto ad inzio giugno perchè mi si era bruciato l'harddisk.. cambiato harddisk, ubuntu nuova e compilava correttamente. considera che evoptool l'ho riscaricato da giugno una settimana fa..

> -il make file di gui ora è come gli altri standard dei vari moduli. era > una versione vecchia e aveva dentro un po' troppe cose inutili questo me l'aveva fatto notare un mio amico smanettone del C, ma anche qui devo impratichirmi con i makefile.

> -quando lanci il programma, a te gnuplot si lamenta così: > "Could not find/open font when opening font "arial", using internal > non-scalable font"? credo sia un problema mio.. credo sia un problema tuo, forse devi installare qualche font associato a gnuplot o direttamente del sistema.

> -quando esco dal programma, a me l'applicazione va in crash. e "Bug > Buddy" di gnome si lamenta.. a te si presenta il problema? forse è un > problema di gcc? con che gcc hai compilato tu? Al momento sto usando gcc 4.3.3, effettivamente mi pareva che nel chiudere l'app lanciava un segmentation fault, probabilmente è qualcosa nel distruttore della classe GUI. Se riesco cerco di risolvere

> -il file sBOA non va in bin, ma va ricompilato dai sorgenti la prima > volta, altrimenti ci possono essere problemi di librerie. io farei un > modulo (o una dir) nella root del progetto dove mettere tutti si > software esterni, al posto di avere una sotto directory in gui > (aggiungere un readme che indica di ricompilare boa al primo checkout) sarebbe l'ideale, io boa non l'ho mai toccato ma comunque andrebbe sistemato.. magari anche per il kill trovare il modo per far comunicare un minimo i due programmi..

> -perché c'è un controllo che se imposto a 30 il problem size me lo fa > passare a 50? cavolatina, semplicemente con glade quando metti gli spinbutton ti chiede un range di valori ed è stato piuttosto casuale.. lo abbasso a 10, che dici? dimmi tu..

> -credo ci sia un problema con la visualizzazione dei dati. quando lancio > sBOA con i parametri: trap5, popsize 3300, size 60, l'agoritmo converge > all'ottimo globale, ma la visualizzazione del grafico non va al 100%. i > valori che visualizzi sono rapportati a 100% come per gli altri algoritmi? > esempio: se lanci insieme anche DEUMd, questo si ferma a 80, e sembra > funzionare meglio di sBOA.. questo era sempre il discorso delle fitness non normalizzate allo stesso modo nei due programmi, non ricordo se trap5 era già presente in boa o l'avevamo aggiunto noi. bisognerebbe ricontrollare tutte le fitness di boa e controllare che siano normalizzate tra 0-100


> -c'è il problema noto che non riusciamo a stoppare sBOA. magari lo stop > potrebbe essere equivalente ad un kill del processo che abbiamo lanciato.. qui il problema più del fare una kill è che bisognerebbe trattare boa in maniera diversa dagli altri algoritmi. Essendo tutto standardizzato bisognerebbe gestirlo in maniera adhoc.. ci avevo già pensato ai tempi, ma non avevo trovato una soluzione semplici.. cose macchinose.


> -mi confermi che manca una implentazione del problema spin glon s, su cui > testare l'efficacia di isDEUM? si, appunto ci sto lavorando in questi giorni ed era l'oggetto di questa mail anche perchè volevo capire quale era il problema di isdeum (implementazione oppure problema da risolvere).

> -domanda: si possono impostare dei valori di default diversi per popsize > per ogni algoritmo? si si tranquillamente, ogni algoritmo selezionato ha il suo pannello dei parametri e sono indipendenti tra loro. L'unica cosa comune tra i diversi algoritmi lanciati è appunto l'istanza del problema da risolvere.


> -non ho capito il funzionamento del TAB2 e del TAB3.. non mi > visualizzano i grafici. credo di non aver capito io come funziona, ma > non vedo nessun output tranquillo, al momento non fanno nulla. Solamente quando ho fatto l'interfaccia l'avevo fatta predisposta per la visualzizazione di diversi grafici (pensando al futuro :-))ma al momento usiamo solo la fitness media.