Usando lenguajes de programación concurrentes para desarrollar algoritmos evolutivos paralelos

Nuevas tendencias en AGps Communicating Sequential Processes Implementacion Resultados Conclusiones

Usando lenguajes de programacionconcurrentes para desarrollar algoritmos

evolutivos paralelos

Autor: MSc. Jose Albert Cruz AlmaguerTutores: Dr. Juan Julian Merelo Guervos (UGR)

Dr.C. Liesner Acevedo Martınez (UCI)

Universidad de Granada, Grupo GENEURA

12 de septiembre de 2014


Summary

1 Nuevas tendencias en AGpsNovedad

2 Communicating Sequential ProcessesCSP

3 ImplementacionCaso GoCaso ScalaCaso ClojureCaso Java

4 Resultados

5 Conclusiones


Novedad

Algoritmos evolutivos

Nuevas tendencias en AGps: plataformas

paralelas

Solamente es considerado el hardware


Novedad

Paradigmas de programacion

Funcional: las funciones como conceptos deprimera clase

Concurrente: presencia de construcciones para

manejar procesos como concepto de primeraclase


Novedad

Clojure

Variante de Lisp

STM/agent/futures

JVM


Novedad

Scala

OO/Funcional

Akka: Concurrencia basada en actores

JVM


Novedad

Go

Estructurado/concurrente

CSP: Concurrencia basada en canales

No VM


CSP

Communicating Sequential Processes

Calculo para estudiar procesos

Lenguaje formal para escribir programas

cercanos a la implementacion


CSP


Base teorica para los modelos de concurrencia

de varios lenguajes

Go, Erlang (por extension a Scala)


CSP


Conceptos fundamentales: Proceso, Canal (channel,

pipe)


CSP

Algoritmos evolutivos

Procesos productor/consumidor

Evaluacion ⇔ Reproduccion

Algorithm 0.1: Behavior of evaluators

Input: Inds: Individuals to evaluate

Input: chReps: Channel to feed the reproducers

beginIndsEval := {(I, V ) | ∀I ∈ Inds, V = fitness(I)}chReps ← sort(IndsEval)

Algorithm 0.2: Behavior of reproducers

Input: Inds: Individuals to reproduce

Input: chEvals: Channel to feed the evaluators

beginchEvals ← Muttation ⊙ Crossover ⊙ Parents-Selection (Inds)

Algorithm 0.3: Behavior of the pool

Input: sortedPool: Individuals already evaluated sorted by fitness

Input: indsPool: Individuals not yet evaluated

Input: chReps: Channel for communication with reproducers

Input: chEvals: Channel for communication with evaluators

beginwhile not Termination-Condition do

chReps ← FirstN (sortedPool)chEvals ← FirstN (indsPool)NInds ← Reps

indsPool + = NInds

NIndsEval ← Evals

sortedPool := merge(sortedPool, NIndsEval)

1


Caso Go

Go

type MaxSATProblem struct{ProblemclauseLength,varsCount,clausesCount intclauses [][]TVarValue}func (self *MaxSATProblem)

FitnessFunction(ind TIndividual) intfunc (self *MaxSATProblem)

QualityFitnessFunction(v int) bool


Caso Go

Go

func (s *ParFitnessQuality)Run(rSol func(res TPoolFitnessQualityResult)){

eJobs := make(chan IDo, 1)rJobs := make(chan IDo, 1)eResults := make(chan TIndsEvaluated, 1)rResults := make(chan TPopulation, 1)doJobs := func(jobs chan IDo) {for job := range jobs {job.Do()}}


Caso Go

Go

addeJobs := func() {active := truefor active {select {case <-control1:active = false

case eJobs <-EJob{p2Eval.ExtractElements(s.MSEvls),s.FitnessF, s.QualityF, Do, eResults}:

}}close(eJobs)}


Caso Go

Go

waitAndProcessResults := func() {for !alcanzadaSolucion {select {case indEvals := <-eResults:p2Rep.Append(indEvals)ce += len(indEvals)

case nInds := <-rResults:p2Eval.Append(nInds)

}}


Caso Go

Go

for i:=0;i < s.CEvaluators; i++{go doJobs(eJobs)

}for i:=0;i < s.CReproducers; i++{go doJobs(rJobs)

}


Caso Go

Go

go addeJobs()go addrJobs()waitAndProcessResults()


Caso Go

Go

func (job EJob) Do() {IndEvals := Evaluate(job.Population, ...)sort.Sort(IndEvals)job.results <- IndEvals

}


Caso Go

Go

func (job RJob) Do() {rResults := Reproduce(job.IndEvals, job.PMutation)job.results <- rResults

}


Caso Scala

Scala

abstract class Problem {def fitnessFunction(ind: TIndividual): Longdef qualityFitnessFunction(v: Long): Booleanprivate[this] def genIndividual(): TIndividualdef getPop(): TPopulation

}


Caso Scala

Scala

class MaxSATProblem extends Problem {override def fitnessFunction(ind: TIndividual): Longoverride def qualityFitnessFunction(v: Long): Boolean

}


Caso Scala

Scala

def r u nPa r F i tQu a l i t y ( r e s : ( TIndEval , Long)=>Uni t ){. . .va l p2Rep = new Rep roduce r sPoo l [ TIndEva l ] ( )va l p2Eva l = new Eva l u a t o r sPoo l [ T I n d i v i d u a l ] ( )va l pResu l tObta i n ed = Promise [ Un i t ] ( )pResu l tObta i n ed . f u t u r e . onSucces s ({

case =>r e s u l tOb t a i n e d ( b e s t S o l u t i on , E v a l u a t i o n s )

})


Caso Scala

Scala

def mkWorker [T ] ( i n d s 2Eva l : L i s t [T ] ,f e e d e r : => L i s t [T ] ,b eg i nAc t i on : L i s t [T ] => Any ,endAct ion : (Any ) => Unit ,cond : => Boolean) : Futu re [ Any ] = {

va l r e s = Future {beg i nAc t i on ( i n d s 2Eva l )

}


Caso Scala

Scala

r e s . onSucces s {case eRe s u l t : Any =>

endAct ion ( eRe s u l t )i f ( cond ) {

va l n i nd s 2Eva l = f e e d e rmkWorker ( n i nd s2Eva l , f e ed e r , b eg i nAct i on

}e l s e {

pResu l tObta i n ed . t r y S u c c e s s ( )}

}r e s

}


Caso Scala

Scala

fo r ( i <− 1 to c o n f i g . Eva l ua to r sCoun t ) {va l i n d s 2Eva l 1 = p2Eva l . e x t r a c tE l emen t s (ECap )mkWorker ( i nd s2Eva l 1 , p2Eva l . e x t r a c tE l emen t s (ECap )

( i n d s 2Eva l : L i s t )=>{va l e v a l s = Eva l u a t o r . e v a l u a t e ( i n d s 2Eva l )e v a l s . s o r tWi th ( . compareTo ( ) > 0)

} , ( r e s u l t : Any ) => {p2Rep . append ( r e s u l t )E v a l u a t i o n s += eRe su l t . l e n g t h

} , ! a l c a n z adaSo l u c i on )}


Caso Scala

Scala

fo r ( i <− 1 to c o n f i g . Reproducer sCount ) {va l i E v a l s 1 = p2Rep . e x t r a c tE l emen t s (RCap)mkWorker ( i E v a l s 1 , p2Rep . e x t r a c tE l emen t s ( RepCap ) ,

( i E v a l s : L i s t ) => {Reproducer . r ep roduce ( i E v a l s . t o L i s t )

} , ( r e s u l t : Any ) => {p2Eva l . append ( r e s u l t )

} , ! a l c a n z adaSo l u c i on )}


Caso Clojure

Clojure

(defprotocol Problem(fitnessFunction [self])(qualityFitnessFunction [self])(genIndividual [self])(getPop [self])(runSeqCEvals [self])(runParCEvals [self r-obtained-notification])(runSeqFitnessQuality [self])(runParFitnessQuality [self r-obtained-notification])

)


Caso Clojure

Clojure

(defn mk-worker [& {:keys [inds2eval feederbegin-action end-action condition p-result-obtained]}]

(loop [inds-2-eval inds2eval](let [

current (future (begin-action inds-2-eval))result @current]

(end-action result)(when (condition)

(recur (feeder)))

))

(deliver p-result-obtained true))


Caso Java

Java

abstract class Problem {abstract long fitnessFunction(TIndividual ind);abstract boolean qualityFitnessFunction(long v);void runParFitnessQuality(FSolutionObtained resultObtained) {


Caso Java

Java

ReproducersPool p2Rep = new ReproducersPool();EvaluatorsPool<TIndividual> p2Eval =new EvaluatorsPool<>();CompletionService<List<TIndEval>> eChannel =new ExecutorCompletionService<>(executor);CompletionService<TPopulation> rChannel =new ExecutorCompletionService<>(executor);


Caso Java

Java

for (int i = 0; i < config.ReproducersCount; i++) {rChannel.submit(new ReproducerJob(p2Rep.extractElements(ReproducersCapacity), reproducer));

}for (int i = 0; i < config.EvaluatorsCount; i++) {

eChannel.submit(new EvaluatorJob(new TPopulation(p2Eval.extractElements(EvaluatorsCapacity)),evaluator));

}


Caso Java

Java

while (!res.alcanzadaSolucion) {Future<List<TIndEval>> fEResult = eChannel.poll();if (fEResult != null) {List<TIndEval> eResult = fEResult.get();evaluations += eResult.size();p2Rep.append(eResult);eChannel.submit(new EvaluatorJob(new TPopulation(p2Eval.extractElements(config.EvaluatorsCapacity)), evaluator));

}


Caso Java

Java

class EvaluatorJob implements Callable<List<TIndEval>> {public List<TIndEval> call() {ArrayList<TIndEval> evals =evaluator.evaluate(inds2Eval);evals.sort((ie1, ie2) -> ie2.compareTo(ie1));return evals;

}


Results

Resultados, MaxSAT (fitness > 420)

Lang Parallel time± SD (ms)

Wscomb

Seq time(ms)

RSpeedup Speedup

Java 303 ± 7.87 6 E, 1R

669.5 2.2 2.2

Scala 661 ± 29.45 27 E,1 R

1215.2 1.83 1.01

Go 676 ± 28.9 29 E,9 R

1182.1 1.74 0.98

Clojure 2959 ± 79.75 10 E,2 R

5689.02 1.92 0.22


Conclusiones

Conclusiones

Ventajas de poseer abstracciones concurrentes: calidad delcodigo

Java: poca calidad pero mejores resultados

Analizar caso Go con mejor rendimento por cantidad deevaluaciones ¿generacion de numeros aleatorios?

Presentations & Public Speaking

Usando lenguajes de programación concurrentes para desarrollar algoritmos evolutivos paralelos