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

Nuevas tendencias en AGps Communicating Sequential Processes Implementación Resultados Conclusiones
Usando lenguajes de programación
concurrentes para desarrollar algoritmos
evolutivos paralelos
Autor: MSc. José Albert Cruz Almaguer
Tutores: Dr. Juan Julián Merelo Guervós (UGR)
Dr.C. Liesner Acevedo Mart´ınez (UCI)
Universidad de Granada, Grupo GENEURA
12 de septiembre de 2014

Summary
1 Nuevas tendencias en AGps
Novedad
2 Communicating Sequential Processes
CSP
3 Implementaci´on
Caso Go
Caso Scala
Caso Clojure
Caso Java
4 Resultados
5 Conclusiones

Novedad
Algoritmos evolutivos
Nuevas tendencias en AGps: plataformas
paralelas
Solamente es considerado el hardware

Novedad
Paradigmas de programaci´on
Funcional: las funciones como conceptos de
primera clase
Concurrente: presencia de construcciones para
manejar procesos como concepto de primera
clase

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
C´alculo para estudiar procesos
Lenguaje formal para escribir programas
cercanos a la implementaci´on

CSP
Base te´orica para los modelos de concurrencia
de varios lenguajes
Go, Erlang (por extensi´on a Scala)

CSP
Conceptos fundamentales: Proceso, Canal (channel,
pipe)

CSP
Algoritmos evolutivos
Procesos productor/consumidor
Evaluaci´on , Reproducci´on

Algorithm 0.1: Behavior of evaluators
Input: Inds: Individuals to evaluate
Input: chReps: Channel to feed the reproducers
begin
IndsEval := {(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
begin
chEvals ← 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
begin
while 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{
Problem
clauseLength,
varsCount,
clausesCount int
clauses [][]TVarValue
}
func (self *MaxSATProblem)
FitnessFunction(ind TIndividual) int
func (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 := true
for 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): Long
def qualityFitnessFunction(v: Long): Boolean
private[this] def genIndividual(): TIndividual
def getPop(): TPopulation
}

Caso Scala
Scala
class MaxSATProblem extends Problem {
override def fitnessFunction(ind: TIndividual): Long
override 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 r od u c e r sPo o l [ TIndEval ] ( )
va l p2Eval = new Ev a l u a t o r sPo o l [ TI n d i v i d u a l ] ( )
va l pRe s u l tOb t a i n ed = Promi s e [ Uni t ] ( )
pRe s u l tOb t a i n ed . f u t u r e . onSuc c e s s ({
case =>
r e s u l tOb t a i n e d ( b e s t S o l u t i o n , E v a l u a t i o n s )
})

Caso Scala
Scala
def mkWorker [T] ( i n d s 2Ev a l : L i s t [T] ,
f e e d e r : => L i s t [T] ,
b e g i nAc t i o n : L i s t [T] => Any ,
endAc t i on : (Any ) => Uni t ,
cond : => Bool ean
) : Futur e [ Any ] = {
va l r e s = Futur e {
b e g i nAc t i o n ( i n d s 2Ev a l )
}

Caso Scala
Scala
r e s . onSuc c e s s {
case eRe s u l t : Any =>
endAc t i on ( eRe s u l t )
i f ( cond ) {
va l n i n d s 2Ev a l = f e e d e r
mkWorker ( n i n d s 2Ev a l , f e e d e r , b e g i nAc t i on
}
e l s e {
pRe s u l tOb t a i n ed . t r y S u c c e s s ( )
}
}
r e s
}

Caso Scala
Scala
for ( i <− 1 to c o n f i g . Ev a l u a t o r sCou n t ) {
va l i n d s 2Ev a l 1 = p2Eval . e x t r a c tEl eme n t s (ECap )
mkWorker ( i n d s 2Ev a l 1 , p2Eval . e x t r a c tEl eme n t s (ECap )
( i n d s 2Ev a l : L i s t )=>{
va l e v a l s = Ev a l u a t o r . e v a l u a t e ( i n d s 2Ev a l )
e v a l s . s o r tWi t h ( . 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 s u l t . l e n g t h
} , ! a l c a n z a d a S o l u c i o n )
}

Caso Scala
Scala
for ( i <− 1 to c o n f i g . Reproduc e r sCount ) {
va l i E v a l s 1 = p2Rep . e x t r a c tEl eme n t s (RCap )
mkWorker ( iEv a l s 1 , p2Rep . e x t r a c tEl eme n t s ( RepCap ) ,
( i E v a l s : L i s t ) => {
Reproduc e r . r ep r od u c e ( i E v a l s . t o L i s t )
} , ( r e s u l t : Any ) => {
p2Eval . append ( r e s u l t )
} , ! a l c a n z a d a S o l u c i o n )
}

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 feeder
begin-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)
Ws
comb
Seq time
(ms)
RSpeedup Speedup
Java 303 ± 7.87 6 E, 1
R
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 del
código
Java: poca calidad pero mejores resultados
Analizar caso Go con mejor rendimento por cantidad de
evaluaciones ¿generación de números aleatorios?

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

Recomendados

Más contenido relacionado

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

Similar a Usando lenguajes de programación concurrentes para desarrollar algoritmos evolutivos paralelos (20)

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