Algoritmi genetici librria JaGA

Introducere
n ultimile decenii, mediul digital a suferit numeroase modificari, evoluia sa fiind surprinztor de accelerat. La fel ca i n mediul natural, unde gradul de adaptabilitate determin ansele de supravieuire ale unei specii, i n mediul digital succesul i longevitatea unei aplicaii sunt condiionate de cat de rapid este modificat aplicaia pentru a corespunde noilor cerine ale utilizatorilor. Astfel, am putea afirma c aplicaiile viitorului sunt aplicaiile ce se adapteaz singure, cu efort minim din partea dezvoltatorilor. O categorie de algoritmi ce pot pune bazele unor astfel de aplicaii o reprezint algoritmii genetici. Datorit faptului c aceti algoritmii au la baz aceeasi structur, dar pot varia destul de mult, putem considera adecvat implementarea acestora folosind un limbaj orientat obiect. JaGA este una dintre librriile ce implementeaz algoritmii genetici in JAVA. Obiectul acestei lucrr1.i il face studiul librriei JaGA n scop didactic, iar rezultatul urmrit este aprofundarea algoritmilor genetici i determinarea dac aceast librrie poate fi folosit cu uurina n dezvoltarea aplicaiilor bazate pe algoritmi genetici.

Algoritmi genetici

Algoritmii genetici au fost inventai de ctre John Holland n anii 1960 i au fost implementai de ctre Holland i un grup de studeni n cadrul Universitii din Michigan ntre anii 1960 - 1970. Scopul iniial al acestor algoritmi a fost de a studia mecanismul de adaptare natural i a descoperi cum ar putea fi utilizat in sistemele informatice Exista o gam larg de domenii ce pot beneficia de pe urma algoritmilor genetici deoarece acetia s-au dovedit capabili s gseasc soluii pentru probleme complexe n rezolvarea crora metodele tradiionale au ntmpinat dificulti.De exemplu, problemele ce

presupun cutarea unei soluii optime ntr-un spaiu larg de soluii cu multe optime locale sunt greu de rezolvat, dac nu imposibil, prin intermediul algoritmilor tradiionali, dar algoritmii genetici reuesc s gseasc o soluie apropiat de optimul global. Din acest motiv, algoritmii genetici au fost aplicai cu succes in domenii precum: Procesarea imaginilor Predicia structurilor de proteine tridimensionale Tehnologii laser Medicin Aeronautic Robotic Cristale lichide Recunoatere facial Proiectarea si antrenarea sistemelor inteligente artificiale, precum reelele neuronale artificiale Ideea de baza a algoritmilor este simpl i urmrete selecia natural n evoluia unei specii. Astfel, pornind de la o populaie aleatoare de indivizi, sau cromozomi (ex. iruri de 1 si 0 codificarea binar fiind una din cele mai utilizate codificri n cadrul algoritmilor genetici) sunt selectai acei indivizi care sunt cei mai potrivii pentru a se reproduce, n funcie de un algoritm de selecie ce simuleaz selecia natural. Asupra indivizilor selectai se aplic o serie de transformri cu scopul de a forma o nou populaie. Operatorii de baz ai acestor transformri sunt inspirai din genetic : ncruciarea, mutaia si inversia. Noua generaie este format de obicei din acei parini selectai , mpreun cu un numr prestabilit de copii. Asupra acestei noi generaii se aplic din nou o serie de transformri, iar algoritmul se repet pn cnd se ndeplinete condiia de oprire, specific fiecrei probleme; soluia este reprezentata de alcel individ(sau indivizi) considerat cel mai potrivit din generaia sa (generaia final) . Cea mai simpl form a algoritmilor genetici include trei tipuri de operatori: - Selecia : acest operator are rolul de a alege din cadrul unei populaii cromozomi pentru a se reproduce. Algoritmii de selecie se bazeaz pe compararea indivizilor in funcie de o caracteristic, de obicei calculat prin intermediul unei funcii fitness. Cu ct un individ este mai potrivit, cu atat are mai multe anse sa fie selectat de mai multe ori pentru a se reproduce.

- ncruciarea : este operatorul prin care, pornind de la doi cromozomi parini se genereaz noi cromozomi. De exemplu, daca se consider irurile prini : 1110011010 si 1100011000 i se alege ca punct de tietur dup a-l treilea bit, se vor obine irurile copii : 11000110010 i 1110011000. - Mutaia : acest operator modific aleator unele gene, n funcie de o anumit proabilitate, care de obicei este foarte mic . De exmplu, o mutaie a irului 000110 poate fi 010110. Implementarea acestor operatori poate diferi de la o problem la alta, n funcie de cerinele specifice. Totui, algoritmii genetici, au n general aceeai structur. Un algoritm genetic simplu respect urmtori pai: 1. Se genereaz aleator o populaie de n cromozomi, fiecare fiind alctuit din l gene. (posibile soluii ale problemei) 2. Se calculeaz fitness(x) pentru fiecare cromozom x al populaiei 3. Se repet urmatorii pai pana cnd n urmai sunt creai: a. Se alege o pereche de cromozomi prini din populaia curent printr-o funcie cresctoare ce depinde de fitness. Aceeai pereche de cromozomi poate fi selectat de mai multe ori pentru a se reproduce. b. Se aplic algoritmul de ncruciare n funcie de o anumit probabilitate, la un punct de tietur ales aleator. Se pot pstra toi copiii rezultai ( daca se folosesc mai multe puncte de tietura pot rezulta mai mult de doi copii) sau se poate alege doar unul din ei. c. Pentru fiecare cromozom copil se aplic o funcie de mutaie 4. Populaia curent se nlocuiete cu noua generaie. 5. Se repet paii 2-4

Rezultatul unui algoritm depinde foarte mult de parametrii prin care este configurat: numarul de indivizi dintr-o populaie, numrul de generaii produse, probabilitiile de ncruciare i de mutaie.

JaGA

JaGA a fost dezvoltat n cadrul Departamentului de Informatic al Universitii College London i este o librrie Java pentru implementarea algoritmilor genetici , creat n scop de cercetare. JaGA pune la dispoziie o serie de algoritmi genetici i de operatori ce faciliteaz dezvoltarea aplicaiilor, iar datorit structurii sale modulare se pot aduga cu uurin noi operatori, prin implementarea uneia sau mai multor interfee pe care librria le pune la dispoziie. Acestea se gsesc n pachetul org.jaga.definitions . Pentru a dezvolta un nou algoritm genetic se poate implementa interfaa GeneticAlgorithm . Librria JaGA pune la dispoziie trei variante de implementri : org.jaga.masterAlgorithm.SimpleGA org.jaga.masterAlgorithm.ElitistGA org.jaga.masterAlgorithm.InitialPopulationGA

Att ElitistGA ct si InitialPopulationGA extind clasa SimpleGA, deci urmresc aceeasi structur, descris n funcia :
public GAResult exec(GAParameterSet params) { if (null == params) throw new NullPointerException("Parameters to a GA may not be null"); int age = 0; Population pop = createInitialPopulation(params); FittestIndividualResult result = (FittestIndividualResult) createResult(); for (int i = 0; i < pop.getSize(); updateIndividualFitness(pop.getMember(i++), pop, age, params)); checkForBetterResult(result, pop, params); notifyInitialisationDone(pop, age, result, params); while (! terminationConditionApplies(pop, age, result, params)) { Individual best = result.getFittestIndividual(); Population nextPop = generateNextPopulation(pop, age, result, params); pop = nextPop; age++; notifyGenerationChanged(pop, age, result, params); if (result.getFittestIndividual() != best) notifyFoundNewResult(pop, age, result, params); } notifyTerminationConditionApplies(pop, age, result, params); return result; }

Elitismul (ElitistGA) este o variant de algoritm genetic prin care se garanteaz supravieuirea celor mai adaptai indivizi, comparativ cu selecia proporional cu caracteristica fitness ce nu favorizeaz nici un individ. Avantajul pstrrii elitei este c algoritmul converge mai rapid la o soluie, prin exploatarea elitei din generaia iniial. Dezavantajul acestei metode este probabilitatea ca soluia gsit s fie optimul global este mai redus comparativ cu metoda simpl, n care este favorizat explorarea spaiului de cutare. Diferenele de implementare dintre elitism si varianta simpl a algoritmului genetic se regsesc n funcia :
protected Population generateNextPopulation(Population oldPop, int age,GAResult result, GAParameterSet params)

Dei de obicei algoritmii genetici pornesc de la o generaie iniial generat aleator, o alt variant ar fi ca generaia iniial s fie compus n funcie de o serie de iniializri a ale indivizilor sau n funcie de diferite metode de estimare a unor soluii aproximative. Clasa InitialPopulationGA implementeaz un algoritm genetic ce pornete de la o populaie specific prin suprascrierea metodei
protected Population createInitialPopulation(GAParameterSet params)

Dup cum se poate observa, pentru a simplifica personalizarea algoritmului n funcie de o problem specific, se folosesc o serie de parametrii, reprezentat de implementri ale interfeei GAParameterSet. Prin intermediul acestui set de parametrii se pot alge diferite variante ale operatorilor de selecie, reproducere (ncruciare + mutaie). Un alt parametru foarte important este algoritmul de calcul al caracteristicii fitness. JaGA pune la dispoziie un set de parametri default, n clasa DefaultParameterSet. Valorile iniiale ale acestor parametrii sunt :
IndividualsFactory indFac = new NDecimalsIndividualSimpleFactory(); Integer popSize = new Integer(100); Integer maxPop = new Integer(500); ReproductionAlgorithm reprAlg = new SimpleBinaryXOverWithMutation(0.65, 0.05); SelectionAlgorithm selAlg = new RouletteWheelSelection(); FitnessEvaluationAlgorithm fitAlg = new LargerDecimals(); Integer mAtt = new Integer(15); RandomGenerator rnd = new DefaultRandomGenerator(System.currentTimeMillis());

Pentru a respecta constrngerile fiecrei probleme, este important ca datele s fie codificate corespunztor. JaGA pune la dispoziie trei tipuri de codificri:

Codificare binara - codul Gray : org.jaga.individualRepresentation.greycodedNumbers.NNumbersGreycodedIndivudual Formule logice arbori de decizie : org.jaga.individualRepresentation.booleanFormulas.BooleanFormulaTree Secvene proteice : org.jaga.individualRepresentation.proteinLocation.ProteinLocationClassifier

Noi tipuri de codificri se pot aduga cu uurin prin implementarea interfeei Individual. Pentru fiecare dintre tipurile de codificare de mai sus, JaGA ofer variante de implementare a functiilor de adecvare i a operatorilor de reproducere.

Exemplu de implementare Problema comis-voiajorului

Rezolvarea unei probleme prin intermediul algoritmilor genetici se rezum, n JaGA, la definirea operatorilor care s respecte constrngerile problemei . Una dintre cele mai cunoscute probleme, adecvat pentru implementarea algoritmilor genetici, este problema comis voiajorului . Soluia pentru aceast problem este un traseu de orae prin care comis voiajorul trebuie s treac o singur dat i s se ntoarc n oraul din care a plecat. Se caut ordinea n care pot fi parcurse aceste orae pentru ca traseul s aib distana minim. Aceast problem este un canditat bun pentru a demonstra uurina cu care se poate extinde librria JaGA, deoarece, pentru a gsi o soluie, este necesar s adjustm operatorii de mutaie i de ncruciare pentru a nu avea orae duplicate n traseu. Primul pas n rezolvarea problemei este codificarea datelor. Dac soluia cutat este o permutare a oraelor prin care trebuie s treac comis voiajorul, cromozom va fi reprezentat de o list ordonat de orae, ordinea acestora determinnd distana parcurs . Cum un cromozom este alctuit din gene, o gen caracteristic problemei TSP este un ora, definit prin nume i coordonate. De asemenea, dac o populaie este altcatuit dintr-o mulime de cromozomi, n cazul problemei TSP , o populaie va fi o colecie de trasee. n JaGA, pentru a defini un tip de codificare, se va implementa interfata Individual. Vom avea deci, clasa Tour, ce conine o list de orae si implementeaz metodele interfeei Individual.
public class Tour implements Individual { private ArrayList<City> tour = new ArrayList<City>(); private Fitness fitness; @Override public Fitness getFitness() { return fitness;

} @Override public void setFitness(Fitness fitness) { this.fitness = fitness; }

Dup definirea datelor problemei relativ la noiunile algoritmilor genetici, urmtorul pas e definirea funciei fitness. Pentru TSP, funcia de adaptare este calculat prin traversarea n ordine a oraelor i insumarea distanei dintre ele. Pentru a gsi distana minim, funcia fitness potrivit este inversul distanei, astfel, cromozomul cu cea mai mare valoare de adecvare va fi cromozomul cu distana cea mai mic. n JaGA calcului funciei fitness se realizeaz prin implementarea interfeei FitnessEvaluationAlgoritm:
public class SalesmanFitness implements FitnessEvaluationAlgorithm { @Override public Class getApplicableClass() { // TODO Auto-generated method stub return Tour.class; } @Override public Fitness evaluateFitness(Individual individual, int age, Population population, GAParameterSet params) throws ClassCastException { Tour tour = (Tour)individual; double tourDistance= 0d; for (int cityIndex=0; cityIndex < tour.tourSize(); cityIndex++) { // Get city we're travelling from City fromCity = tour.getCity(cityIndex); // City we're travelling to City destinationCity; // Check we're not on our tour's last city, if we are set our // tour's final destination city to our starting city if(cityIndex+1 < tour.tourSize()){ destinationCity = tour.getCity(cityIndex+1); } else{ destinationCity = tour.getCity(0); } // Get the distance between the two cities tourDistance = fromCity.distanceTo(destinationCity); } return new TSPFitness(1/tourDistance,tourDistance); } }

Operaiile de reproducere folosite n problema comis voiajorului trebuie s creeze cromozomi copii care nu conin gene duplicate. Pentru implementare am ales un algoritm de ncruciare simplu, care

selecteaz din primul printe un subset de orae, apoi introduce pe poziiile libere orae din cel de-al doilea printe, ce nu se regsesc deja n cromozomul copil. De asemenea, pentru a nu introduce trasee invalide n noua generaie, operatorul de mutaie ales se reduce la o simpl operaie de interschimbare a genelor , n funcie de o rat de mutaie. n JaGA, algoritmul de reproducere se definete prin implemntarea interfeei ReproductionAlgorithm :
public class SalesmanReproductionAlgorithm implements ReproductionAlgorithm { @Override public int getRequiredNumberOfParents() { return 2; } @Override public Class getApplicableClass() { return Tour.class; } @Override public Individual[] reproduce(Individual[] parents, GAParameterSet params) throws ClassCastException, IllegalArgumentException { Individual child= crossover(parents); mutate(child); return new Individual[] {child}; }

Dup ce am definit operatorii specifici, este momentul sa configurm algoritmul . Pentru asta am folosit clasa DefaultParameterSet astfel:
GAParameterSet params = new DefaultParameterSet(); params.setPopulationSize(500); params.setFitnessEvaluationAlgorithm( new SalesmanFitness()); params.setSelectionAlgorithm(new TournamentSelection(5, 0.7)); params.setMaxGenerationNumber(100); TourFactory fact = new TourFactory(); params.setIndividualsFactory(fact); params.setReproductionAlgorithm(new SalesmanReproductionAlgorithm());

Librria JaGA pune la dispoziie un tool de analiz ce faciliteaz urmrirea rezultatelor problemei. Pentru acelai set de orae, putem observa rezultate diferite n funcie de parametrii setai. De exemplu pentru o populaie de 100 de indivizi, dup 10 generaii, soluia gsit este Q(200, 40)|B(180, 200)|A(60, 200)|I(40, 120)|M(120, 80)|L(60, 80)|H(140, 140)|O(20, 40)|J(100, 120)|S(60, 20)|E(20, 160)|R(20, 20)|C(80, 180)|P(100, 40)|T(160, 20)|K(180, 100)|D(140, 180)|G(200, 160)|F(100, 160)|N(180, 60) - QBAIMLHOJSERCPTKDGFN

, cu o distana de 28.284. Algoritmul a rulat timp de 00:00.326 secunde.

Pentru o populaie de 500 , dup 10 generaii, soluia gsit este : R(20, 20)|K(180, 100)|A(60, 200)|L(60, 80)|C(80, 180)|D(140, 180)|F(100, 160)|Q(200, 40)|I(40, 120)|B(180, 200)|J(100, 120)|S(60, 20)|M(120, 80)|G(200, 160)|P(100, 40)|N(180, 60)|H(140, 140)|T(160, 20)|E(20, 160)|O(20, 40) - RKALCDFQIBJSMGPNHTEO ; cu o distana de 20.0 , timp de execuie 00:00.665

Concluzii
Librria JaGA este o librrie uor de folosit, foarte util n dezvoltarea aplicaiilor simple ce au ca scop familiarizarea cu algoritmii genetici, deoarece ofer dezvoltatorului libertatea de a-i defini noi operatori, noi variante ale algoritmilor genetici, dar totodata ofer o serie de operatori deja definii ce pot fi utilizai cu succes n rezolvarea problemelor.

Bibliografie
1. Java developers journal - An Introduction to Genetic Algorithms in Java (http://www2.syscon.com/itsg/virtualcd/java/archives/0603/lacy/index.html#s4) 2. The Project Spot Applying a genetic algorithm to the travelling salesman problem (http://www.theprojectspot.com/tutorial-post/applying-a-genetic-algorithm-to-the-travellingsalesman-problem/5) 3. David A. Coley - An Introduction to Genetic Algorithms for Scientists and Engineers, Ed. World Scientific, 2003 4. Melanie Michell An Introduction to Genetic Algorithms , Ed. The MIT Press, 1998

Cuprins
INTRODUCERE ................................................................................................................................................... 1 JAGA .................................................................................................................................................................... 3 EXEMPLU DE IMPLEMENTARE PROBLEMA COMIS-VOIAJORULUI .................................................... 6 CONCLUZII ............................................................................................................................................................ 10 BIBLIOGRAFIE ....................................................................................................................................................... 11