<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Omar Andres Carmona Cortes on Medium]]></title>
        <description><![CDATA[Stories by Omar Andres Carmona Cortes on Medium]]></description>
        <link>https://medium.com/@omarandrescarmonacortes?source=rss-ec82d1ac36df------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*tfVjO-vAnDVzlk-z.</url>
            <title>Stories by Omar Andres Carmona Cortes on Medium</title>
            <link>https://medium.com/@omarandrescarmonacortes?source=rss-ec82d1ac36df------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 21:15:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@omarandrescarmonacortes/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Implementando a Evolução Diferencial em R]]></title>
            <link>https://medium.com/semper-evolutionis/implementando-a-evolu%C3%A7%C3%A3o-diferencial-em-r-e31f59c9f52?source=rss-ec82d1ac36df------2</link>
            <guid isPermaLink="false">https://medium.com/p/e31f59c9f52</guid>
            <category><![CDATA[evolução-diferencial]]></category>
            <category><![CDATA[otimização]]></category>
            <category><![CDATA[r]]></category>
            <dc:creator><![CDATA[Omar Andres Carmona Cortes]]></dc:creator>
            <pubDate>Fri, 29 Dec 2017 03:01:06 GMT</pubDate>
            <atom:updated>2017-12-29T03:01:06.168Z</atom:updated>
            <content:encoded><![CDATA[<p>A evolução diferencial foi proposta por Storn e Price em 1997 [1]. Seu funcionamento é muito similar a dos AGs, porém com os operadores invertidos. Enquanto nos AGs executa-se o cruzamento e depois a mutação, na evolução diferencial (ED) o processo é inverso, ou seja, primeiro realiza-se a mutação para em seguida executar o cruzamento. O algoritmo é apresentado a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/437/1*ln9QNNBC6AkoCL5eA0lsdQ.png" /></figure><p>Assim como nas outras meta-heurísticas que apresentei, na ED uma população inicial aleatória de tamanho <em>n</em> e dimensão <em>d</em> é criada com o código a seguir, que basicamente é o mesmo dos algoritmos genéticos (AGs).</p><pre>init.population &lt;- function(func,lb,ub,pop.size,dimension){<br>   pop &lt;- matrix(runif(pop.size*dimension),nrow=pop.size)<br>   fitness &lt;- rep(NA,pop.size)<br>   pop &lt;- lb + pop*(ub-lb)<br>   fitness &lt;- apply(pop,1,func)<br>   return(list(pop = pop, fit = fitness))<br>}</pre><p>Em seguida entra-se no laço até atingir o critério de parada. Dentro desse laço, três indivíduos são selecionados aleatoriamente. Em seguida a diferença entre dois dos indivíduos (<em>idx1 </em>e <em>idx2</em>) é multiplicado pelo fator <em>F</em> sendo adicionado a um terceiro indivíduo (<em>idx3</em>). A ordem não precisa ser necessariamente essa, ou seja, poderia ser a diferença entre 3 e 2 sendo adiciona a 1, por exemplo, como será feito no código. Essa operação é a criação do vetor de diferenças, que também é chamada de mutação. Além disso, essa operação dá nome à estratégia utilizada no processo de otimização. No caso apresentado, a estratégia é chamada <em>DE/Rand/1</em>, pois a operação de seleção é aleatória e gera um vetor <em>v</em> para cada seleção de 3 indivíduos.</p><p>Outra estratégia que pode ser utilizada é a DE/Best/1, na qual o elemento de indice 3 sempre será o melhor indivíduo da população, enquanto <em>idx1</em> e <em>idx2</em>, continuam aleatórios. Aqui incentivo o leitor a buscar por outras estratégias que podem ser usadas na ED.</p><p>O código a seguir ilustra em R como as duas estratégias mencionadas podem ser implementadas. Note que na estratégia DE/Best/1, o melhor individuo é replicado em um vetor (<em>best</em>), facilitando assim a operação vetorial sem a necessidade de uma instrução <em>for</em>.</p><pre>if(strategy == 1){ #DE/Rand/1<br>   idx &lt;- matrix(sample(1:pop.size,3*pop.size,replace = TRUE),nrow =   <br>          pop.size)<br>}<br>else { #DE/Best/1<br>   idx &lt;- matrix(sample(1:pop.size,2*pop.size, replace = TRUE), <br>          nrow = pop.size)<br>   best &lt;- rep(which.min(fit),pop.size)<br>   idx &lt;- cbind(best,idx)<br>}<br>v &lt;- pop[idx[,1],] + F * (pop[idx[,2],] - pop[idx[,3],])</pre><p>Em seguida para cada dimensão do vetor um valor aleatório é sorteado, se esse valor for menos do que o <em>crossover rate</em> (taxa de cruzamento) o gene do novo indivíduo virá do vetor de diferenças, caso contrário virá do elemento da população que estiver sendo mutado. Particularmente em R, costumo criar a matriz inteira de CRs, isto é, para todos os genes da população, e em seguida formar a nova população usando indexação lógica, como mostrado no código abaixo:</p><pre>r &lt;- matrix(runif(pop.size*dimension), nrow = pop.size)<br>idx &lt;- r &lt; pc<br>new.pop[idx] &lt;- v[idx]<br>new.pop[!idx] &lt;- pop[!idx]<br>new.fit &lt;- apply(new.pop,1,func)</pre><p>E para finalizar é necessário identificar quem dos novos indivíduos são melhores do que a população atual, o que também é feito através da indexação lógica:</p><pre>idx &lt;- new.fit &lt; fit<br>fit[idx] &lt;- new.fit[idx]<br>pop[idx,] &lt;- new.pop[idx,]</pre><p>E pronto, esta finalizado o algoritmo. O código a seguir é da função completa de ED. Adiciono a ela somente um pedaço de código no qual verifico se os vetores de diferenças estão dentro dos limites inferior e superior de cada gene.</p><pre>DE &lt;- function(func,lb,ub,pop.size,dimension,iterations,F, pc = <br>               0.6,strategy = 1){<br>  tmp.pop &lt;- init.population(func,lb,ub,pop.size,dimension)<br>  pop &lt;- tmp.pop$pop<br>  fit &lt;- tmp.pop$fit<br>  new.pop &lt;- matrix(rep(NA, pop.size * dimension), nrow = pop.size)<br>  new.fit &lt;- c()<br>  for(i in 1:iterations){<br>    if(strategy == 1){<br>       idx &lt;- matrix(sample(1:pop.size, 3 * pop.size, replace = <br>              TRUE), nrow = pop.size)<br>    }<br>    else {<br>      idx &lt;- matrix(sample(1:pop.size, 2 * pop.size, replace = <br>             TRUE), nrow = pop.size)<br>      best &lt;- rep(which.min(fit),pop.size)<br>      idx &lt;- cbind(best,idx)<br>    }<br>    <br>    #Verifies lower and upper bounds<br>    v &lt;- pop[idx[,1],] + F * (pop[idx[,2],] - pop[idx[,3],])<br>    idx &lt;- which(v &lt; lb,arr.ind=TRUE)<br>    v[idx] &lt;- lb[idx[,2]]<br>    idx &lt;- which(v &gt; ub,arr.ind=TRUE)<br>    v[idx] &lt;- ub[idx[,2]]<br>    <br>    #Crossover<br>    r &lt;- matrix(runif(pop.size*dimension), nrow = pop.size)<br>    idx &lt;- r &lt; pc<br>    new.pop[idx] &lt;- v[idx]<br>    new.pop[!idx] &lt;- pop[!idx]<br>    <br>    #Update population <br>    new.fit &lt;- apply(new.pop,1,func)<br>    idx &lt;- new.fit &lt; fit<br>    fit[idx] &lt;- new.fit[idx]<br>    pop[idx,] &lt;- new.pop[idx,]<br>  }<br>  return(list(pop = pop, fit = fit))<br>}</pre><p>O código de teste esta logo abaixo o qual pode selecionar tanto a função de Schwefel quanto a de Rosenbrock, bastando comentar a linha correta e estabelecer os novos limites inferiores e superiores, respectivamente:</p><pre>source(&#39;DE.R&#39;)<br>source(&#39;init.population.R&#39;)<br>#source(&#39;./../Numerical-Benchmarks/Rosenbrock.R&#39;)<br>source(&#39;./../Numerical-Benchmarks/Schwefel.R&#39;)</pre><pre>dim &lt;- 30<br>it &lt;- 2000<br>pop.size &lt;- 50<br>lb &lt;- rep(-500,dim)<br>ub &lt;- rep(500,dim)<br>func &lt;- Schwefel<br>execs &lt;- 20<br>F &lt;- 0.3<br>pc &lt;- 0.6</pre><pre>#DE/Rand/1 = 1<br>#DE/Best/1 = 2<br>strategy &lt;- 2</pre><pre>result &lt;-  vector(&quot;list&quot;,execs)<br>best &lt;- rep(NA,execs)</pre><pre>for(i in 1:execs){<br>   cat(&quot;exec = &quot;,i,&quot;\n&quot;)<br>   result[[i]] &lt;- DE(func,lb,ub,pop.size,dim,it,F, pc=0.6,strategy)<br>   best[i] &lt;- min(result[[i]]$fit)<br>}</pre><pre>print(min(best))</pre><p>A função de Schwefel foi apresentada no artigo “<a href="https://medium.com/semper-evolutionis/programa%C3%A7%C3%A3o-evolutiva-em-r-c9c39d998b1">Programação Evolutiva em R</a>” enquanto que a Rosenbrock foi mostrada no artigo “<a href="https://medium.com/semper-evolutionis/implementado-algoritmos-gen%C3%A9ticos-em-r-845219a56984">Implementando AGs em R</a>”.</p><p>[1] STORN, R. and PRICE, K. Differential evolution — A simple and efficient heuristic for global optimization over continuous spaces. J. Global Optimization, v. 11, pp. 341–359, 1997.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e31f59c9f52" width="1" height="1" alt=""><hr><p><a href="https://medium.com/semper-evolutionis/implementando-a-evolu%C3%A7%C3%A3o-diferencial-em-r-e31f59c9f52">Implementando a Evolução Diferencial em R</a> was originally published in <a href="https://medium.com/semper-evolutionis">Semper Evolutionis</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Programação Evolutiva em R]]></title>
            <link>https://medium.com/semper-evolutionis/programa%C3%A7%C3%A3o-evolutiva-em-r-c9c39d998b1?source=rss-ec82d1ac36df------2</link>
            <guid isPermaLink="false">https://medium.com/p/c9c39d998b1</guid>
            <dc:creator><![CDATA[Omar Andres Carmona Cortes]]></dc:creator>
            <pubDate>Fri, 15 Dec 2017 18:45:10 GMT</pubDate>
            <atom:updated>2018-11-26T18:29:54.079Z</atom:updated>
            <content:encoded><![CDATA[<p>Continuando os posts relacionados à programação de algoritmos evolutivos em R, vou mostrar como implementar a programação evolutiva em R. Se você não conhece R tire uns minutos para ler o artigo “<a href="https://medium.com/semper-evolutionis/o-que-voc%C3%AA-precisa-saber-sobre-linguagem-r-para-implementar-algoritmos-evolutivos-6cf765bdf34a">O que você precisa saber sobre linguagem R para implementar algoritmos evolutivos</a>”. Para outras implementações visite o “<a href="https://medium.com/semper-evolutionis">Semper Evolutionis</a>”.</p><p>Então mãos a obra!</p><p>A programação evolutiva (PE) foi proposta por Fogel em 1966 [1] e desde então tem sido aplicada com sucesso principalmente na resolução de problema de otimização numérica. Seu algoritmo é relativamente simples como podemos ver no pseudocódigo a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SCtXnoRtEnlT8ahxJDeyKQ.png" /></figure><p>O algoritmo da PE é bastante semelhante a outros algoritmos evolutivos. E como evolutivo, deve-se criar uma população inicial aleatória no domínio especificado pelo problema. Porém, aqui há uma diferença se comparado com, por exemplo, algoritmos genéticos (AGs). Na PE um indivíduo é formado pela sua posição no espaço de busca <em>x</em> mais um vetor de desvios padrão <em>n</em>. O vetor de desvios padrão será a base para modificar a posição x no espaço de busca. O código em R para inicializar a população é:</p><pre>init.population &lt;- function(pop.size,dimension,lb,ub){<br>   pop &lt;- matrix(runif(pop.size*dimension),nrow=pop.size)<br>   pop &lt;- lb + pop * (ub-lb)<br>   std.dev &lt;- matrix(runif(pop.size*dimension),nrow=pop.size)<br>   return(list(pop = pop,std.dev = std.dev))<br>}</pre><p>Ao entrar no laço cada indivíduo deve gerar um filho de acordo com a equação abaixo, na qual a nova posição no espaço sera formada pela posição atual mais o desvio padrão multiplicado por um número aleatório de Cauchy ou pode-se usar também um número aleatório normal com média zero e desvio padrão igual a 1, sendo que o desvio padrão também será mutado. Vale destacar que <em>Nj(0,1)</em> refere-se a um número aleatório para cada gene enquanto que N(0,1) refere-se a um único número aleatório por indivíduo. Nas constantes <em>tau</em> e <em>tau’</em>, <em>d </em>indica a quantidade de genes ou a dimensão do problema.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/409/1*s3oPkoterRIR7vg8jQ9gWA.png" /></figure><p>O gráfico abaixo mostra o que seria um número aleatório normal com essas características, ou seja, de acordo com essa função haverá uma maior probabilidade de se gerar números aleatórios mais ou menos entre -2 e 2.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*E0TrGfLqegEf_w3X4HePmw.jpeg" /></figure><p>Após avaliar os filhos (calcular a aptidão dos novos indivíduos) deve-se fazer a união entre os filhos e os genitores com o objetivo de realizar um torneio, ou seja, cada indivíduo sera comparado com outros q indivíduos selecionados aleatoriamente dentro da população unida. Para cada indivíduo computa-se quantas vitórias cada um teve. A nova geração será formada pelos indivíduos que obtiveram o maior número de vitórias. Segue o código em R para o restante do algoritmo:</p><pre>EP &lt;- function(func,pop.size, dimension,lb,ub,num.it,q){<br>   tau  &lt;- sqrt(2 * sqrt(pop.size))^-1<br>   taul &lt;- sqrt(2 * pop.size)^-1<br>   pop &lt;- init.population(pop.size, dimension,lb,ub) <br>   x &lt;- pop$pop<br>   std.dev &lt;- pop$std.dev<br>   fit &lt;- apply(x,1,func)<br>   for(i in 1:num.it){<br>      #Cria filhos usando Cauchy mutation<br>      n1 &lt;- matrix(rcauchy(pop.size*dimension),nrow=pop.size) <br>      xl &lt;- x + std.dev * n1</pre><pre>      #Verifica os limites de cada gene dos filhos <br>      idx &lt;- which(xl &lt; lb, arr.ind=TRUE)<br>      xl[idx] &lt;- lb[idx[,2]]<br>      idx &lt;- which(xl &gt; ub, arr.ind=TRUE)()<br>      xl[idx] &lt;- ub[idx[,2]]</pre><pre>      #Cria novos desvios    <br>      n1 &lt;- rnorm(pop.size, mean = 0, sd = 1)<br>      n.norm &lt;- rnorm(1, mean = 0, sd = 1)<br>      std.devl &lt;- std.dev * exp(taul*n.norm + tau*n1)<br>      fitl &lt;- apply(xl,1,func)</pre><pre>      #Faz a união entre pais e filhos<br>      tmp.pop &lt;- rbind(xl,x)<br>      tmp.fit &lt;- c(fitl,fit)<br>      tmp.std &lt;- rbind(std.devl,std.dev)<br>      </pre><pre>      #Computa as vitórias de cada individuo<br>      win &lt;- rep(NA, pop.size*2)<br>      for(j in 1:(2*pop.size)){ <br>         idx &lt;- sample(1:(2*pop.size),q)<br>         win[j] &lt;- length(which(tmp.fit[j] &lt; tmp.fit[idx]))<br>      }</pre><pre>      #Une as duas populações e ordena pelo numero de vitorias<br>      #Em seguida trunca-se pelo tamanho da população<br>      merge &lt;- cbind(win,tmp.fit,tmp.pop,tmp.std)<br>      merge &lt;- merge[order(merge[,1],decreasing = TRUE),]<br>      x &lt;- merge[1:pop.size,3:(dimension+2)]<br>      fit &lt;- merge[1:pop.size,2]<br>      std.dev &lt;- merge[1:pop.size,(dimension+3):(dimension*2 + 2)]<br>   }<br>   return(list(pop=x,fit=fit,eta=std.dev))<br>}</pre><p>O próximo código é o script de teste onde se pretende minimizar a função de Schwefel cujo mínimo é -12569,49.</p><pre>dimension &lt;- 30<br>max.it &lt;- 9000<br>pop.size &lt;- 100<br>q &lt;- 10</pre><pre>func &lt;- Schwefel<br>low &lt;- -500<br>high &lt;- 500<br>lb &lt;- rep(low,dimension)<br>ub &lt;- rep(high,dimension)</pre><pre>r &lt;- EP(func,pop.size,dimension,lb,ub,max.it,q)</pre><pre>print(min(r$fit))</pre><p>O código para função de Schwefel é:</p><pre>Schwefel &lt;- function(x){<br>   y &lt;- sum(-x*sin(sqrt(abs(x))))<br>   return(y)<br>}</pre><p>Espero que tenham gostado de mais este post e nos encontramos em breve com outro algoritmos evolutivo ou de enxame.</p><p>[1] L. J. Fogel, A. J. Owens, and M. J. Walsh, Artiﬁcial Intelligence Through Simulated Evolution. New York: Wiley, 1966.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c9c39d998b1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/semper-evolutionis/programa%C3%A7%C3%A3o-evolutiva-em-r-c9c39d998b1">Programação Evolutiva em R</a> was originally published in <a href="https://medium.com/semper-evolutionis">Semper Evolutionis</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementando PSO em R]]></title>
            <link>https://medium.com/semper-evolutionis/implementado-pso-em-r-f1dddce6c71b?source=rss-ec82d1ac36df------2</link>
            <guid isPermaLink="false">https://medium.com/p/f1dddce6c71b</guid>
            <dc:creator><![CDATA[Omar Andres Carmona Cortes]]></dc:creator>
            <pubDate>Mon, 04 Dec 2017 19:05:00 GMT</pubDate>
            <atom:updated>2017-12-21T08:31:45.750Z</atom:updated>
            <content:encoded><![CDATA[<p>Seguindo a linha de implementações de algoritmos evolutivos e de enxame em R, vamos implementar um PSO (<em>Particle Swarm Optimization</em>), em português conhecido como Otimização por Nuvem de Partículas. Para não criar confusão com nome em português ou inglês, irei sempre me referir ao algoritmo como PSO.</p><p>Antes de começarmos, se você não sabe nada de R então sugiro a leitura do artigo “<a href="https://medium.com/semper-evolutionis/o-que-voc%C3%AA-precisa-saber-sobre-linguagem-r-para-implementar-algoritmos-evolutivos-6cf765bdf34a">O que você precisa saber sobre linguagem R para implementar algoritmos evolutivos</a>”. Caso queira entender o funcionamento dos Algoritmos Genéticos antes de começar o PSO, então leia o artigo “<a href="https://medium.com/semper-evolutionis/implementado-algoritmos-gen%C3%A9ticos-em-r-845219a56984">Implementando Algoritmos Genéticos em R</a>”.</p><p>Então vamos começar…</p><p>O PSO não é exatamente um algoritmo evolutivo, mas sim um algoritmo de enxame. Essa linha é comumente chamada de inteligência de enxame ou inteligência coletiva, abrangendo algoritmos tais como PSO, Colônia de Formigas (<em>Ant Colony</em>), Colonia de Abelhas Artificias (<em>Artificial Bee Colony</em>), Alimentação Bacteriana (<em>Bacterial Foraging</em>), dentre outros. A principal diferença desses algoritmos com relação aos evolutivos é que os de enxame simulam o comportamento de sociedades de indivíduos, normalmente no processo de busca por alimentação.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*l1Xjbgl8X3xFs5xtNOvOpA.jpeg" /></figure><p>Proposto por J. Kenndy e R. Eberhart em 1995 em seu artigo “Particle Swarm Optimization” [1], o PSO tornou-se um dos algoritmos mais importantes no mundo da otimização contínua, possuindo também variações para otimização multiobjetivo, na qual dois ou mais objetivos conflitantes devem ser otimizados. Seu objetivo é simular o comportamento de pássaros em busca de alimentos e embora inicialmente criado para simulação comportamental, rapidamente foi aplicado na otimização numérica.</p><p>Bom, vamos ao algoritmo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/819/1*0cS58yRJMnAA2joxBNTRCw.png" /></figure><p>Ao inicializarmos o enxame, três importantes matrizes devem ser criadas: o enxame propriamente dito (<em>S</em>), que representa a posição das partículas no espaço de busca, o histórico da melhor posição por onde a partícula já passou (<em>P</em>) e a velocidade (<em>V</em>), sendo que <em>fitness </em>é o vetor que contem a avaliação de <em>S</em>e <em>P.fit</em> é o vetor que contém o fitness da melhor posição já visita por cada partícula. Com essas estruturas definidas cria-se ainda o vetor <em>g</em> que armazena a melhor posição até o momento e <em>g.fit</em> que é seu fitness.</p><p>Após o processo de inicialização começa-se as iterações do algoritmo, que equivale às gerações dos algoritmos genéticos. Enquanto o critério de parada não é alcançado, atualiza-se a matriz de velocidade usando <em>w</em> (peso de inércia), <em>c1</em> e <em>c2</em> (constantes aceleradoras), e, <em>r1</em> e <em>r2</em> (matrizes de variáveis aleatórias entre 0 e 1). Observe que a velocidade utiliza os dois melhores fitness encontrados para direcioná-la para em seguida atualizar as posições. Após a atualização da posição de cada partícula verifica-se se o melhor fitness (<em>g.fit</em>) foi melhorado e se as novas posições são melhores do que o histórico das partículas.</p><p>Já acabou? Sim, o algoritmo é bastante simples. Então vamos por a mão na massa em R.</p><p>A função de inicialização é mostrada a seguir, na qual são inicializadas as matrizes <em>S</em>, <em>P</em> e <em>V</em>. Um detalhe que não foi tratado no algoritmo são os parâmetros <em>v.min</em> e <em>v.max</em> que tem como objetivo controlar a velocidade das partículas, pois elas podem crescer indefinidamente, o que gera a chamada explosão de velocidade, que faz com que o algoritmo perca a capacidade de <em>exploitation</em>, ou seja, de busca local.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/887/1*iNG7NP7B4jWskNwa7KXb3g.png" /></figure><p>O resto da implementação é mostrada na figura abaixo, na qual faz-se uma alocação de memória para as matrizes e se inicializam as estruturas necessárias. Já nas iterações do algoritmo, observe como a atualização tanto das velocidades quanto da posição das partículas é feito em instruções matriciais. Em seguida verifica-se se nenhuma dimensão da partícula ultrapassou os limites inferior e superior, respectivamente, fazendo a mesma coisa na matriz de velocidades. Aqui é importante introduzir um novo parâmetro da função <em>which() </em>que é o <em>arr.ind = TRUE</em>. Esse parâmetro devolve a posição da matriz em que a condição é verdadeira. Se fosse usada a instrução <em>which(S &lt; lb)</em>, sem o parâmetro <em>arr.ind</em>,<em> </em>seriam mostrados os valores que ferem essa condição e não os índices. Os índices também formam uma matriz, e por <em>lb</em> e <em>ub</em> serem vetores, é mandatório usar a segunda posição dos índices que contém a coluna que não obedece a condição (<em>idx[,2]</em>). Na verdade, a operação <em>S[idx] &lt;- lb[idx[,2]]</em> obriga que a quantidade de elementos seja a mesma em ambos os lados. A operação é feita se a quantidade não for igual, mas irá gerar um <em>warning</em> que não é facilmente detectado durante a execução, e consequentemente, irá gerar resultados errados. Já quando os limites da velocidade são verificados pode-se utilizar a indexação lógica simples, pois <em>v.min</em> e <em>v.max</em> são escalares.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/889/1*7sRxmYbcvS2xrK1iIbHkog.png" /></figure><p>O script de teste é mostrado a seguir. Nele são definidas os parâmetros de execução do PSO, sendo <em>w</em> um número menor que 0.9, e, <em>c1</em> e <em>c2</em> normalmente igual a 2.</p><p>Ainda é possível implementar um decaimento linear para a variável de inércia <em>w</em>. Para isso é necessário trocar <em>w</em> por dois novos parâmetros <em>w.min</em> e <em>w.max</em>, normalmente, 0.9 e 0.4, respectivamente,<em> </em>e computar <em>w</em> através da equação:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/583/1*s_qOgwGxKeYcEhOI0xwUZg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/887/1*WfmoZR2EuCN0jw5OtSKNSA.png" /></figure><p>O PSO é um algoritmo bastante simples de se implementar, especialmente em R. Espero que tenham gostado e comecem a praticar esse conhecimento o mais rápido possível. Para saber mais…</p><p>[1] Kennedy, J.; Eberhart, R. (1995). <a href="http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=488968">“Particle Swarm Optimization”</a>. <em>Proceedings of IEEE International Conference on Neural Networks</em>. <strong>IV</strong>. pp. 1942–1948.</p><p>[2] Shi, Y.; Eberhart, R.C. (1998). <a href="http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=699146">“A modified particle swarm optimizer”</a>. <em>Proceedings of IEEE International Conference on Evolutionary Computation</em>. pp. 69–73.</p><p>[3] Kennedy, J. (1997). “The particle swarm: social adaptation of knowledge”. <em>Proceedings of IEEE International Conference on Evolutionary Computation</em>. pp. 303–308.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f1dddce6c71b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/semper-evolutionis/implementado-pso-em-r-f1dddce6c71b">Implementando PSO em R</a> was originally published in <a href="https://medium.com/semper-evolutionis">Semper Evolutionis</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[O que você precisa saber sobre linguagem R para implementar algoritmos evolutivos]]></title>
            <link>https://medium.com/semper-evolutionis/o-que-voc%C3%AA-precisa-saber-sobre-linguagem-r-para-implementar-algoritmos-evolutivos-6cf765bdf34a?source=rss-ec82d1ac36df------2</link>
            <guid isPermaLink="false">https://medium.com/p/6cf765bdf34a</guid>
            <category><![CDATA[programação]]></category>
            <category><![CDATA[r]]></category>
            <category><![CDATA[algoritmos-evolutivos]]></category>
            <dc:creator><![CDATA[Omar Andres Carmona Cortes]]></dc:creator>
            <pubDate>Fri, 01 Dec 2017 23:27:20 GMT</pubDate>
            <atom:updated>2020-04-17T21:23:14.990Z</atom:updated>
            <content:encoded><![CDATA[<p>Como eu já mencionei no meu artigo “<a href="https://medium.com/semper-evolutionis/implementado-algoritmos-gen%C3%A9ticos-em-r-845219a56984">Implementando Algoritmo Genéticos em R</a>”, a escolha pela linguagem R se deve a quatro principais fatores: facilidades de trabalhar com matrizes e vetores; é uma linguagem pronta pra análise estatística; possui mais de 10.000 pacotes em seu repositório; e, não menos importante, é <em>free</em>. Neste artigo trataremos do essencial para podermos implementar algoritmos evolutivos: variáveis, vetores e matrizes, funções, listas e funções de grupo.</p><p>Neste artigo estamos usando <a href="https://www.r-project.org/">R</a> 64 bits versão 3.3.3 e <a href="https://www.rstudio.com/">RStudio</a> 1.0.136. Bem, vamos começar então a falar logo sobre R!</p><h3>Variáveis</h3><p>O primeiro conceito visto em qualquer linguagem são as variáveis. Como R é uma linguagem não fortemente tipada, como o são Linguagens como C, Java, dentre outras, não é necessário definí-las previamente. Muito embora, pré-definir vetores e matrizes ajude o programa a executar mais rapidamente. Outra característica importante é que variáveis em R são case sensitive, ou seja, minúsculas e maiúsculas são consideradas diferentes. Finalmente, uma atribuição é feita através do símbolo ‘&lt;-’. Na verdade pode-se utilizar o símbolo ‘=’ como em outras linguagens, mas eu tentei usá-lo e meu código gerou resultados estranhos. Por esse motivo prefiro focar no tradicional e usar o símbolo ‘&lt;-’. Então são atribuições válidas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/106/1*fp14qgC1FRiNTgmpxoxTYA.png" /></figure><p>Observe que a terceira atribuição está invertida, porém é valida, pois o símbolo ‘-&gt;’ indica que o valor 4 está sendo atribuído à variável <em>c</em>. Outra característica interessante da linguagem R é a atribuição múltipla, na qual duas ou mais variáveis podem ser atribuídas em uma única instrução:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/205/1*Z8PRrOcvLx9n8YMtPEK9EQ.png" /></figure><p>Mas quais identificadores eu posso usar na linguagem R? Já estava chegando lá. Além das regras básicas da maioria das linguagens de não poder começar com um número nem com caracteres especiais, em R permite-se a utilização do underscore ‘_’ e do ponto ‘.’. Por isso, em R o identificador <em>tamanho.pop</em> é válido, ou seja, <em>pop</em> <strong>não é</strong> o atributo de um objeto chamado <em>tamanho</em>. Muito embora em R seja possível programar de forma orientada a objetos, este não é o objetivo deste artigo.</p><h3>Vetores</h3><p>Assim como em outras linguagens, um vetor é um conjunto ou coleção de variáveis do mesmo tipo. Seu acesso é através de colchetes, sendo a primeira posição 1 e não 0. Os vetores em R são inicializados usando a função <em>c() </em>de combinar (<em>combine </em>em inglês). Uma característica interessante, que também esta presente em <a href="https://www.mathworks.com/products/matlab.html">Matlab</a> e em <a href="http://www.numpy.org/">NumPy</a> (Python), é o acesso consecutivo a elementos. Em R também é possível acessar elementos não consecutivos usando vetores como índices (isso também está disponível em Matlab. Em Numpy eu não sei :P). A seguir mostramos um exemplo de como criar um vetor e os tipos de acessos mencionados.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/508/1*0kAsd7EyW6dhdslzxwkoaA.png" /></figure><p>Observe que no exemplo <em>a[c(1, 4, 2)]</em> estamos acessando a posições 1, 4 e 2 do vetor <em>a</em>. O mesmo se aplica aos vetores de strings.</p><p>Um aspecto interessante da função <em>c() </em>é que ela permite a concatenação de dois ou mais vetores, estejam eles criados ou não. Por exemplo, considerando o vetor <em>a</em>, a função <em>c(a, c(10, 9, 8)) </em>concatenaria o vetor <em>a</em> com o vetor [10, 9, 8]. Vale destacar que varias combinações podem ser feitas em uma única função <em>c() </em>como mostrado a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/528/1*WbzpHyzUCjhZbcmvYEHhuw.png" /></figure><p>Três funções que trabalham em cima de vetores são importantes: <em>length()</em>, <em>rep()</em> e <em>which()</em>. A função <em>length()</em> devolve a quantidade de elementos de um vetor. A função <em>rep() </em>repete o elemento definido pela quantidade de vezes especificada na função. Esta função é importante quando o vetor é formado pelo mesmo valor em todas as posições, ou, para alocar espaço de memória antes de um laço. A alocação não é necessária em R, porém, deixa a execução do código mais rápida se efetuada. A função <em>which(condição) </em>devolve os índices dos elementos do vetor que obedecem a uma condição especificada. A figura abaixo mostra um exemplo de uso dessas funções.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*dShlm7uhOpYfuJrFOq-Jpw.png" /></figure><p>A partir da função <em>which()</em> derivam-se duas importantes funções para quem quer implementar algoritmos evolutivos: <em>which.min()</em> e <em>which.max()</em>. Estas funções devolvem o índice do menor e maior elemento dentro de um vetor respectivamente.</p><h3>Matrizes</h3><p>Juntamente com os vetores, as matrizes são a alma na implementação de algoritmos evolutivos, sendo criadas a partir do uso da função <em>matrix() </em>cujos parâmetros mais importantes são: (i) o vetor que será transformado em matriz; (ii) a quantidade de linhas ou colunas; e (iii) se a matriz será gerada por linha ou por coluna. Se o terceiro parâmetro for omitido a matriz será criada por coluna, que é a notação matemática de matrizes. Caso se queira criar uma matriz por linhas, deve-se usar o parâmetro <em>byrow = TRUE</em>, como mostrado no exemplo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/744/1*GdZFgNmPFipRP7nwU-h4qw.png" /></figure><p>O acesso a um elemento em uma matriz segue uma sintaxe similar a Linguagem C, ou seja, <em>variável[linha,coluna] (variável[linha][coluna] </em>em C<em>)</em>. Aqui se estendem a forma de acesso dos vetores. Por exemplo, <em>v &lt;- A[2,] </em>implica que a linha 2 da matriz A esta sendo atribuída ao vetor <em>v</em>. O mesmo pode ser feito em termos de colunas, isto é, <em>v &lt;- A[,2] </em>indica que a coluna 2 esta sendo atribuída ao vetor <em>v</em>. Esta característica é bastante útil quando algortimos evolutivos são implementados. Aqui podemos também brincar com os acessos definindo faixas. Por exemplo, <em>B &lt;- A[1:5,]</em>, implica que as linhas de 1 a 5 serão alocadas à matriz <em>B</em>; <em>B &lt;- A[1:2,3:5]</em> indica que <em>B</em> será uma matriz formada pelas linhas 1 e 2, e pelas colunas de 3 a 5 de <em>A</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/885/1*TBv0lZmeLIWr0CbGVXF7Vw.png" /></figure><p>Todas as operações matriciais em R são <em>element-wise</em>, ou seja, elemento por elemento. Então, se <em>A</em> e <em>B</em> são matrizes, o resultado de <em>A * B</em> será cada elemento de <em>A</em> multiplicado pelo respectivo elemento de <em>B</em>. E assim são feitas as demais operações: soma, subtração e divisão.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*vgQksIEfTLA8hMd35mIZSQ.png" /></figure><p>As operações <em>matriz operador escalar</em> ou <em>matriz operador vetor</em> também são permitidas. A primeira será aplicada em todos os elemento da matriz. O segundo tipo de operação (<em>matriz op vetor</em>) é um pouco traiçoeira: se o tamanho do vetor for equivalente a quantidade de colunas a operação será feita em termos de colunas, caso contrário em termos de linhas. Porém, se ambos forem iguais (quantidade de linhas = quantidade de colunas), haverá a precedência para que a operação seja feita em termos de colunas. Caso seja impossível evitar que a quantidade de linhas e de colunas seja igual e que você precisa executar a operação em termos de linhas, então você terá que recorrer a função <em>t()</em>, que tem como objetivo fazer a transposta da matriz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/1*vgQksIEfTLA8hMd35mIZSQ.png" /></figure><p>Outra solução possível para o caso <em>linhas </em>x<em> colunas</em> é a utilização da função <em>sweep()</em>, mas deixo esse pequeno trabalho de pesquisa para você leitor.</p><p>Agora, para realizar a multiplicação e a divisão tradicional de matrizes, utilizam-se os operadores <em>%*%</em> e <em>%/%</em>, respectivamente. Isso mesmo, <em>porcentagem asterisco porcentagem</em> e <em>porcentagem barra porcentagem</em>.</p><p>Agora que sabemos como manipular vetores e matrizes, vamos falar um pouco sobre <strong>indexação lógica</strong>, que permite acesso a elementos (vetores ou matrizes) através de condições lógicas. Esta é uma característica poderosa que permite que operações sejam feitas em diferentes elementos de uma matriz sem a necessidade da utilização de estruturas de laços. Imagine que temos uma matriz 6 x 6 de números aleatório entre 0 e 1, e que queremos determinar os índices de todos os números menores que 0.2, por exemplo. Com essas informações podemos realizar operações diretamente em todos esses elementos em que a condição é verdadeira. Se, por exemplo, essa matriz representar uma população, seria fácil determinar quais elementos estão fora do domínio permitido. Veja um exemplo logo a seguir, no qual a função <em>runif(n)</em> gera <em>n</em> números aleatórios entre 0 e 1:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/887/1*yHKk-1ewub0MbnwfLwLpnw.png" /></figure><p>No exemplo apresentado, atribuímos à variável <em>idx</em> o resultado da condição que queremos, ou seja, <em>A &lt; 0.2. </em>Como se pode observar, o resultado da condição é uma matriz de elementos lógicos. Essa matriz pode ser utilizada como um gabarito que irá selecionar quais elementos serão substituídos pelo valor -1. Como a matriz resultante da condição é uma matriz lógica, a utilização da cláusula not (!) também é válida. Por exemplo, o código a seguir atribuiria o valor -1 a todos os elementos que não satisfazem a condição.</p><pre>idx &lt;- A &lt; 0.2<br>A[!idx] &lt;- -1</pre><p>Essa mesma funcionalidade pode ser aplicada com vetores, ou seja, <em>matriz condição vetor</em>, ou até mesmo <em>matriz condição matriz</em>, tendo o cuidado de sempre assegurar que a quantidade de elementos a serem substituídos coincide com a quantidade de elementos sendo atribuídos. Isso é importante porque caso isso não seja feito, o R não irá mostrar uma mensagem de erro e sim apenas um <em>warning</em> após o término do programa, tornando a depuração mais complexa.</p><p>Aqui cabe uma informação importante. Vocês se lembram que diferentes elementos podem ser indexados através da função <em>c()</em>? Isso se estende às matrizes também. Vamos supor que queremos indexar um conjunto de linhas aleatoriamente selecionadas através da função <em>sample()</em> como a seguir:</p><pre>idx &lt;- sample(1:100, 5)<br>A[idx,] &lt;- novos.individuos()</pre><p>O trecho de código apresentado gera 5 números inteiros aleatórios na faixa de 1 a 100. Em seguida esses números são usados como índices para geração de novos indivíduos, por exemplo. Mas, e se quisermos fazer o contrário, isto é, criar novos indivíduos nos outros índices? Seria <em>A[!idx]</em>? Não, isso não funcionaria porque <em>idx</em> não é um vetor ou uma matriz lógica. Para solucionar esse problema seria necessário indexar as linhas através de <em>A[-idx]</em>.</p><h3><strong>Listas</strong></h3><p>Listas podem armazenar objetos de diferentes tipos. Assim, uma função pode devolver mais de um objeto ao mesmo tempo. Isso é particularmente importante na implementação de evolutivos porque é comum uma função ter que devolver uma população (matriz) e as respectivas aptidões (vetor). Claro, se o programador não quiser devolver tudo como uma matriz só, combinando a população com os seus respectivos <em>fitnesses</em> usando a função <em>cbind()</em> (combinação de colunas). Eu particularmente prefiro retornar essas estruturas de forma separada usando listas.</p><p>O acesso aos elementos de uma lista é parecido ao que se faz em um vetor. Porém, deve-se usar colchetes duplos. Vejamos no exemplo a seguir, no qual são criados dois vetores e uma matriz, sendo todos atribuídos à lista <em>MyList</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/690/1*TtEnzialgIu8FZ88BdAMEQ.png" /></figure><p>Uma característica interessante das listas é que você pode atribuir nomes aos objetos que compõem a lista. Essa característica tende a tornar os programas em R mais legíveis e fáceis de entender. Os nomes são dados durante a chamada a função <em>list </em>e muda a sintaxe de acesso aos objetos, exigindo a utilização do caractere ‘$’ seguido pelo nome do objeto como mostrado no exemplo a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/887/1*sv1rxaAUGJDBh1I-vvP4Iw.png" /></figure><p>Muito embora a atribuição de nomes aos objetos que compõem uma lista torne o programa mais legível, o padrão de acesso usando colchetes duplos continua válido.</p><h3>Funções</h3><p>A criação de funções é um elemento crucial em qualquer linguagem de programação, sejam procedimentos em linguagens procedurais ou métodos em linguagens orientadas a objetos. Em R, a sintaxe para criação de funções é <em>nome_da_função &lt;- function(parâmetros)</em>, isto é, o nome da função que recebe a palavra reservada <em>function </em>seguido dos parâmetros entre parênteses.</p><p>Se a função precisar de mais de uma instrução então ela deve ser limitada por chaves, da mesma forma como ocorre com funções em C ou métodos em Java, sendo que a última instrução deve ser uma função <em>return() </em>garantindo que a função retorne algum valor.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/433/1*-u94N5DH3kv31xgn9TRnYw.png" /></figure><p>Um detalhe que deve ser lembrado é que as funções em R devem ser carregadas na memória antes de serem usadas. Isso pode ser feito através do botão <em>source </em>que fica no canto superior esquerdo do código ou através da função <em>source(‘nome_do_arquivo.R’)</em> no código. Outro detalhe é que um único arquivo pode contar várias funções. Usar um arquivo por função ou várias funções em um arquivo é uma questão de gosto do programador. Eu gosto de usar uma função por arquivo, pois é mais fácil de <em>debugar. </em>No caso de ter que implementar várias funções, costumo agrupá-las no mesmo arquivo de acordo com seus propósitos, por exemplo, <em>mutacao.R</em> contém todas as funções de mutação que podem ser utilizadas.</p><p>Vamos voltar um pouco para as listas, quando queremos que uma função retorne diferentes estruturas é necessário a utilização da função <em>list()</em>. A sintaxe desse tipo de retorno é:</p><pre>return(list(nome1 = estrutura1, nome2 = estrutura2, ... ))</pre><p>No caso de programação de algoritmos evolutivos costumo utilizar algo do tipo <em>return(list(population = pop, fitness = fit))</em>, na qual <em>pop </em>é uma matriz e <em>fit </em>é um vetor. Para acessar essas estruturas utiliza-se a sintaxe <em>variável$nome</em>, por exemplo, <em>new.pop$population</em> para acessar a população e <em>new.pop$fitness</em> para acessar o vetor de <em>fitness</em> retornados pela minha função.</p><p>No console do RStudio é possível também criar uma função, basta seguir a sintaxe. Quando o programador abre as chaves o console espera até que a mesma seja fechada. Quando isso ocorre a função é carregada automaticamente para a memória.</p><h3>Funções de Grupo</h3><p>Os códigos em R que usam laços (<em>for</em>, <em>while</em>) são mais lentos do que os códigos que usam funções de grupo, pois esse tipo de função normalmente é otimizada, sendo muitas vezes implementada em linguagem C. Então é altamente recomendável tentar achar uma solução para seu problema que não use laços.</p><p>De maneira geral, as funções de grupo atuam tanto em matrizes quanto em vetores. Se o parâmetro de entrada é um vetor, o retorno normalmente é um escalar. Quando o parâmetro de entrada é uma matriz, normalmente o retorno é um vetor, mas pode ser também um escalar, depende da função. Alguns exemplos de funções de grupo são: <em>sum()</em>, <em>mean()</em> e <em>sd()</em>. Essas funções de exemplo devolvem escalares mesmo quando matrizes são utilizadas, pois aplicam a operação soma (<em>sum</em>), média (<em>mean</em>) e desvio padrão (<em>sd</em>) em todos os seus elementos. Caso o programador queira, por exemplo, somar em termos de colunas ou linhas deve usar as funções <em>colSums()</em> ou <em>rowSums() </em>como mostrado a seguir. Sim, o ‘S’ no meio das funções é maiúsculo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/785/1*LqqaC-b3qoUef0xbhFR3nw.png" /></figure><p>Como pudemos observar, as funções <em>colSums()</em> e <em>rowSums()</em> devolvem a soma de colunas e de linhas, respectivamente. Isso evita a utilização de laços para essa operação. Ai você pode se perguntar, e se eu tiver que aplicar uma função que eu desenvolvi em linhas ou colunas de uma matriz? Bom, para isso existe a função <em>apply</em> cuja sintaxe é <em>apply(object, margin, function, parameters)</em>, na qual <em>object</em> é a matriz que será trabalhada, <em>margin </em>indica se a operação será em termos de linhas (1) ou colunas (2), <em>function </em>é a função que será usada na matriz e <em>parameters </em>são os parâmetros que sua função precisa.</p><p>Mas por que você esta passando um <em>object</em> e não uma <em>matrix</em>?</p><p>Porque a função <em>apply()</em> pode ser utilizada também por uma estrutura de dados em R chamada de <em>data.frame</em>, mas isso é outra história.<em> :)</em></p><p>Vamos a utilização da função <em>apply</em>. Vamos supor que nós temos uma população de 10 indivíduos com uma dimensão 5, ou seja, uma matriz 10 x 5, e desejamos calcular a aptidão dessa população usando a função <a href="http://www-optima.amp.i.kyoto-u.ac.jp/member/student/hedar/Hedar_files/TestGO_files/Page2530.htm">Schwefel</a>, por exemplo. O código para essa operação é mostrado a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/991/1*pN_oXhXlyCie88AiplJTQA.png" /></figure><p>Observe como nesse pequeno exemplo utilizamos vários conceitos vistos neste artigo: matrizes, vetores (sim <em>runif(50)</em> gera um vetor de 50 posições de números aleatórios), funções e funções de grupo.</p><p>Com este último exemplo chegamos ao fim. Com este artigo eu espero duas coisas: que você se sinta incentivado a programar em R e que seja um primeiro passo no mundo dos algoritmos evolutivos. Se quiser mais detalhes de como implementar um Algoritmo Genético em R sugiro o artigo: <a href="https://medium.com/semper-evolutionis/implementado-algoritmos-gen%C3%A9ticos-em-r-845219a56984">Implementando Algoritmos Genéticos em R</a> de minha autoria. Também é possível ver um tutorial de aplicações de Algoritmos Genéticos em Otimização Numérica na <a href="http://seer.upf.br/index.php/rbca/article/view/9047">Revista Brasileira de Computação Aplicada</a>.</p><p>Neste artigo também não introduzimos a utilização de estruturas de controle, pois assumimos que o leitor já tem pelo menos um conhecimento básico em programação. Além disso, essas estruturas são muito parecidas em outras linguagens como C, Matlab ou Java, com pequenas diferenças em suas sintaxes.</p><p>Para saber mais sobre R…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/356/1*vGxFJe-JyMMComoXEDMk3A.png" /></figure><p>Este livro é bem geral fornecendo um overview bem amplo dos recursos que a linguagem R possui, partindo de sua instalação, passando pelas suas estruturas de dados, estruturas de controle, criação de gráficos, manipulação de dados e estatística.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/334/1*gG2AXZpTgihgCwaPhIcayw.jpeg" /></figure><p>Embora este livro tenha uma introdução ao R mostrando seus conceitos básicos e estruturas de dados, este livro é mais direcionado aos que pretendem utilizar a linguagem como ferramenta estatística.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6cf765bdf34a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/semper-evolutionis/o-que-voc%C3%AA-precisa-saber-sobre-linguagem-r-para-implementar-algoritmos-evolutivos-6cf765bdf34a">O que você precisa saber sobre linguagem R para implementar algoritmos evolutivos</a> was originally published in <a href="https://medium.com/semper-evolutionis">Semper Evolutionis</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementado Algoritmos Genéticos em R]]></title>
            <link>https://medium.com/semper-evolutionis/implementado-algoritmos-gen%C3%A9ticos-em-r-845219a56984?source=rss-ec82d1ac36df------2</link>
            <guid isPermaLink="false">https://medium.com/p/845219a56984</guid>
            <category><![CDATA[r]]></category>
            <category><![CDATA[algoritmos-genéticos]]></category>
            <category><![CDATA[inteligência-artificial]]></category>
            <category><![CDATA[algoritmos-evolutivos]]></category>
            <dc:creator><![CDATA[Omar Andres Carmona Cortes]]></dc:creator>
            <pubDate>Thu, 30 Nov 2017 09:14:35 GMT</pubDate>
            <atom:updated>2020-01-02T19:44:49.711Z</atom:updated>
            <content:encoded><![CDATA[<p>A primeira pergunta que pode passar pela sua cabeça é “por que em <a href="https://www.r-project.org/">R</a>?”. Bom, vários são os motivos. Vou tentar enumerar os principais deles que consigo me lembrar. Primeiro, é uma linguagem que contém inúmeras facilidades para se trabalhar com vetores e matrizes, estruturas de dados estas que são a base para a implementação de algoritmos evolutivos e de enxame. Segundo, é uma linguagem que possui mais de 10.000 pacotes em seu repositório (<a href="https://cran.r-project.org/">CRAN</a>) em 2017, isso mesmo, mais de dez mil pacotes, que variam de aplicações em ecologia, passando por equações diferenciais, aprendizagem de máquina, dentre muitas outros. Terceiro, é uma linguagem pronta para estatística, ou seja, já possui todas as funções necessárias para realizar comparações estatísticas entre algoritmos. E quarta, mas não menos importante, é completamente <em>free</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*1Lo3WdfMyDBVK4vPbAWnIA.png" /></figure><p>Antes de começar a mostrar a implementação, é importante que o leitor esteja seguro que conhece quatro importantes conceitos de R que serão amplamente usados neste artigo: vetores, matrizes, listas e funções de grupo. Acessar vetores e matrizes em R é muito semelhante ao que se faz em linguagens como C e Java, porém com as mesmas facilidades apresentadas pelo <a href="https://www.mathworks.com/products/matlab.html">Matlab</a>, tais como, operações diretas com vetores e matrizes, e indexação lógica. Listas são como objetos que armazenam diferentes tipos de dados. Por exemplo, uma lista pode ser formada por três estruturas de dados diferentes, tais como, um vetor, uma matriz e uma variável inteira, não necessariamente nessa ordem. Muito embora seja possível trabalhar com R de forma orientada a objetos, neste artigo iremos trabalhar de forma procedimental. Finalmente, funções de grupos são funções que permitem ao programador executar operações em vetores e matrizes sem a necessidade de utilizar laços tais como <em>for</em> e <em>while</em>. Na verdade, o uso de funções de grupo são preferíveis ao uso de laços, pois elas normalmente são implementadas de forma otimizada. Além disso, estou assumindo também que o leitor já possua um certo conhecimento em algoritmos.</p><p>Então vamos começar!</p><p>Neste momento você deve estar se perguntando, mas o que é um Algoritmo Genético (AG)? Formalmente é uma meta-heurística baseada no processo de seleção natural na qual o indivíduo que melhor se adapta ao ambiente é o que sobrevive.</p><p>What?</p><p>Calma. Vamos passo a passo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/334/1*Ss1dIwPPudwip5kP9JtV1Q.png" /></figure><p>Imagine que em um deserto existem duas espécies de animais: pequenos répteis, que vou chamar de lagartixas, e uma ave de rapina, vamos supor que seja uma águia. Se as lagartixas forem, por exemplo, de cor avermelhada, e a velocidade de reprodução delas não for muito grande, em pouco tempo as águias irão extinguí-las. Agora imagine que por uma mutação genética uma lagartixa nasceu bege, ou seja, mais próximo da cor da areia do deserto. Se essa lagartixa não se mexer enquanto esta sobre a areia, a águia não conseguirá vê-la. Na verdade eu não sei se a águia irá ou não vê-la, mas vamos supor que não. Nesse caso, a nova lagartixa terá mais chances de sobreviver, e como consequência de gerar novos descendentes. Todos nós sabemos que ao gerar descendentes, estes terão parte do material genético dos geradores. Isso significa que há uma probabilidade de que as lagartixas descendentes da lagartixa bege sejam da mesma cor. Assim, essa mutação irá equilibrar as coisas entre as lagartixas e as águias, até que uma águia sofra uma mutação que permita visualizar sua presa.</p><p>Então, tomando como base o exemplo das lagartixas e águias, podemos começar a entender conceitos como seleção, cruzamento e mutação, que são as principais operações dos AGs. O processo de seleção natural é aquele em que os mais aptos tem maior probabilidade de sobreviver e transmitir seus genes. Essa adaptação se deu, no exemplo, pela mutação quando a lagartixa mudou de cor. Já, quando as lagartixas geraram novos descendentes através do compartilhamento genético houve o que se conhece como cruzamento.</p><p>Neste ponto, já temos quase toda a teoria necessária para começarmos a entender como funciona um AG. Mas calma, ainda precisamos de mais um pouco de teoria. Na verdade, precisamos definir como simular esse processo em um algoritmo que possa ser executado em um computador.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/329/1*J88vn7n0nIhQW0MVBjjRMg.jpeg" /></figure><p>Segundo Norvig, um AG é um algoritmo de busca local, no qual a geração de um novo estado não depende seu histórico, mas somente do seu estado atual. Conceitualmente isso esta correto. No entanto, no mundo da computação evolutiva, os AGs são conhecidos como algoritmos de busca global, pois seu objetivo é fazer uma busca geral no que conhecemos como espaço de busca. Mas em que isso muda os conceitos envolvidos em AGs? Boa pergunta! No mundo da computação evolutiva também existe o conceito de busca local, que é a busca por soluções em uma região próxima ao estado atual. É desses conceitos que derivam os conceitos conhecidos em inglês como <em>Exploration </em>e <em>Exploitation</em>. O primeiro refere-se a capacidade de busca global, enquanto que o segundo refere-se a capacidade busca local. Nesse contexto, é interessante que o algoritmo tenha uma boa capacidade de <em>Exploration </em>em grande parte de sua execução; e uma boa capacidade de <em>Exploitation </em>na parte final de sua execução, já que imagina-se que no final o algoritmo já se encontre próximo da solução ótima.</p><p>Mas que diabos esse AG esta buscando?</p><p>AGs buscam soluções para um problema. Imagine que você quer encontrar o menor caminho saindo de uma cidade qualquer, passando por várias cidades, como por exemplo, São Luis, Bacabal, Santa Inês, Imperatriz, Açailandia, Carolina, Santa Luzia e Arari. Não seria inteligente, por exemplo, fazer a rota inicial São Luis — Açailandia — Santa Inês — Imperatriz — Arari, pois se gastaria muito combustível e tempo. Por outro lado, a sequencia inicial São Luis —Arari — Santa Inês — Santa Luzia — Açailandia seria mais adequada. Nesse exemplo, o espaço de busca seria a combinação de todas as cidades. Matematicamente, seria a combinação das 8 cidades 8-a-8, onde não pode haver repetições. Esse problema é conhecido como o problema do caixeiro viajante e nesse exemplo em particular gera um espaço de busca de 40320 possibilidades de combinações.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/203/1*VwZoGsrltMbIlz1xnnPYSA.png" /></figure><p>Algoritmicamente, sabendo o aspecto que se deseja avaliar, com por exemplo a distância percorrida, é possível encontrar a solução para o problema das cidades usando força bruta, ou seja, testando todas as possibilidades. Devemos lembrar que o exemplo tem apenas 8 cidades. Quando o problema passa a ter mais cidade, 21 por exemplo, o espaço de busca aumenta para 51.090.942.171.709.440.000 possibilidades. Literalmente cinquenta e um quintilhões de possibilidades. Agora imagine que você tem um processador de 3 Ghz, o que dá aproximadamente 3.000.000.000 de operações por segundo (aqui não estou considerando <em>pipeline, </em>paralelismo<em> </em>e outras características que podem deixar o processamento mais rápido), para terminar a avaliação de todas as possibilidades são necessários aproximadamente 4.730.643 horas ou 197 mil dias ou 540 anos, isto é, inviável.</p><p>Agora sabendo que podemos precisar de um AG, é necessário definir o que seria um indivíduo. Seria uma lagartixa? Isso, mas precisamos de algo mais preciso ou mais formal. No caso das cidades, um indivíduo seria uma sequencia de cidades a serem visitadas. Se as cidades forem numeradas na sequencia 1-São Luis, 2-Bacabal, 3-Santa Inês, 4-Imperatriz, 5-Açailandia, 6-Carolina, 7-Santa Luzia e 8-Arari, o vetor a seguir é um individuo válido, isto é, uma possível solução.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/246/1*kDw5XYfZ9x1gw2vkhkGAGg.png" /></figure><p>Ah entendi. Então se uma solução é um indivíduo, cada cidade é um gene? Exatamente! Desse conceito derivamos os AGs binários, cujos genes são formados apenas por 0s e/ou 1s, e os AGs em código real, no qual os genes podem ser números inteiros ou reais. E a partir da representação podemos introduzir os operadores de cruzamento e de mutação.</p><p>O operador de cruzamento mais comum é o cruzamento simples. Nesse cruzamento, dois genitores e um ponto de corte são escolhidos. Em seguida são gerados dois filhos trocando-se os genes de cada pai. Considerando então dois pais com código real, poderíamos ter algo como apresentado na figura a seguir (o mesmo processo serve para indivíduos com código binário). Não estamos usando o exemplo das cidades porque esse exemplo em particular exige a utilização de operadores especiais que serão vistos em outro post.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/534/1*ADBN7cSvRydG4sBFxiIfHw.png" /></figure><p>Com o cruzamento feito, agora podemos mostrar o que é a mutação. No caso de um AG em código real, a mutação mais simples, também chamada de uniforme, é feita gerando-se um número aleatório dentro do domínio de cada gene, isto é, um número é gerado considerando os limites inferior e superior do gene. No caso do AG ser binário, basta trocar 0 por 1 e vice-versa, como mostrado a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/455/1*TC-PLYzpL0fgXZO9r0WY7Q.png" /></figure><p>Agora já sabemos como funcionam os principais operadores, portanto já podemos apresentar o algoritmo e começar a colocar a mão na massa. Mas calma, primeiro precisamos definir qual o problema que vamos resolver. Suponhamos que o problema a ser resolvido é minimizar a função:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/395/1*ywz0PhqL7_5Q45s7DhwAyg.png" /></figure><p>Essa função é bem conhecida no mundo da computação evolutiva, chamada de Rosenbrock, sendo bastante difícil de solucionar em grandes dimensões. Em duas dimensões, o objetivo é encontrar o ponto mínimo da figura a seguir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/524/1*9coIliDuxGhfa3OQXASmUw.png" /></figure><p>Considerando a função Rosenbrock em duas dimensões, resolver esse problema é relativamente fácil. Mas você não acabou de dizer que é difícil? Sim, em grandes dimensões. O gráfico mostrado representa apenas duas dimensões, ou variáveis. Além disso, como pode ser observado, essa função é genérica, na qual <em>d </em>representa uma dimensão qualquer, normalmente 30, tornando bastante difícil o processo de encontrar sua solução ótima. O domínio de cada gene no nosso código deve estar no intervalo [-5,5], em testes com o código você pode definir outros limites. O mínimo dessa função é um vetor de 1s, ou seja, [1,…,1]. Como estamos considerando uma dimensão igual a 30, o mínimo será um vetor de 30 posições.</p><pre>Rosenbrock &lt;- function(x){<br>  d &lt;- length(x)<br>  xi &lt;- x[1:(d-1)]<br>  xnext &lt;- x[2:d]<br>  sum &lt;- sum(100*(xnext-xi^2)^2 + (xi-1)^2)<br>  return(sum)<br>}</pre><p>Com esses dados nas mãos já podemos começar a nossa implementação. Eu costumo usar o <a href="https://www.rstudio.com/">RStudio</a>, que é uma IDE open source que tem o apoio da comunidade de R, porém essa IDE não é obrigatória, pois existem outras como, por exemplo, a <a href="http://blog.revolutionanalytics.com/2016/01/microsoft-r-open.html">Microsoft R</a> (antes conhecida como Revolution R) que é <em>free</em> para estudantes.</p><p>Vamos ao código? Let’s do this!</p><p>Vamos começar apresentando o algoritmo canônico do AG. Para colocar logo a mão na massa irei explicando o algoritmo juntamente com o código em R</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/679/1*odVdjV4Xl0ScOMqb7b2KEA.png" /></figure><p>O código para testar o AG é apresentado a seguir, no qual carregam-se todas as funções que serão usadas pelo código através da instrução <em>source</em>. Esses códigos são os mesmos apresentados no restante deste artigo e possuem o mesmo nome das funções que implementam. Em seguida definem-se a dimensão do problema (<em>dim</em>), a quantidade de iterações (<em>it</em>) que é o critério de parada do AG, os limites inferior e superior (<em>lb</em> e <em>ub</em>), a função que será otimizada (<em>func</em>), a quantidade de execuções (<em>execs</em>), um vetor que receberá uma lista de resultados e um vetor que conterá a melhor solução encontrada em cada execução. Para o AG ainda são passadas: a probabilidade de cruzamento (<em>pc</em>), a probabilidade de mutação (<em>pm</em>) e o tipo de seleção que será usado (<em>sel = 1</em> indica <em>roulette wheel</em>; <em>sel = 2</em> indica <em>tournament</em>)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0wiahSi7Lf1ywVijfDH66w.png" /></figure><p>A função GA é muito similar ao algoritmo canônico, mas com dois parâmetros a mais, que são o tamanho do torneio (para seleção via torneio) e se o elitismo será ou não feito. Como o parâmetros <em>t.size </em>não estão sendo passado pelo código de teste, adota-se o padrão definido no código (<em>t.size = 4</em>) do AG propriamente dito (função GA no código).</p><p>No AG canônico quando uma nova população é criada ela substitui a população corrente. Em alguns casos, a nova população não contém nenhum individuo melhor que a população corrente, o que faz com que esse individuo seja perdido. O que por um lado pode diminuir um pouco a pressão seletiva, mas por outro lado, pode fazer a população retroceder em termos de evolução. Quando o elitismo é usado, garante-se que pelo menos o melhor individuo passe de uma geração (iteração) para outra.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FqS2qTfBfwo8TiE652hbvQ.png" /></figure><p>Quando a função GA é chamada, o primeiro passo do algoritmo é executado, que é inicializar a população de modo aleatório, mas dentro do domínio de cada gene. Isso é feito pela função <em>init.population()</em>. Observe que apesar de precisar criar vários indivíduos e cada um com 30 genes, nenhuma instrução de laço é utilizada. Note também a função <em>apply </em>que aplica a função Rosenbrock para cada linha da matriz criada. Esse processo é chamado de cálculo de aptidão ou <em>fitness</em>, e quando feita em toda população determina-se a função de <em>Avalia População()</em> do AG canônico.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VSCeqFPzcY4d5k6VTnsWtQ.png" /></figure><p>O próximo passo é entrar no laço onde as gerações são executadas, sendo a primeira função a de seleção. O processo de seleção visa escolher dentro da população quais individuos devem ser cruzados. Isso pode ser feito de diversas formas, sendo que na maioria deles utiliza-se como base a aptidão dos indivíduos. A função <em>selection()</em> apenas escolhe se a seleção será feita via roleta (<em>roulette wheel</em>) ou competição (<em>tournament</em>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nI8Yntxu4gt2Y0bWw4-rIA.png" /></figure><p>Vamos começar estudando o algoritmo de seleção por roleta, no qual para cada indivíduo é dada um probabilidade de ser escolhido. Essa probabilidade é obtida através da divisão de cada aptidão pela soma de todas as aptidões da população. Em seguida é computada a probabilidade cumulativa de cada indivíduo de modo a poder selecionar os indivíduos por sorteio. É como se para cada indivíduo fosse dado um pedaço de uma roleta de acordo com sua aptidão. Assim, quanto maior a aptidão, maior o pedaço da roleta. O processo é mostrado no algoritmo a seguir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7d7Y9UuP7k-nQY0QL4kwFw.png" /></figure><p>Como se pode observar, cada individuo recebe um pedaço maior da roleta se tiver uma aptidão maior. Isso faz com que o método da roleta seja adequado para problemas de maximização. Por outro lado, um artifício matemático permite que um problema de maximização seja transformado em um problema de minimização, pois <em>Max f(x) = Min -f(x)</em>. Nesse caso, o código em R para seleção via roleta fica como mostrado logo abaixo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iXsv5nkFfQ1knjYKEsnWGQ.png" /></figure><p>Observe no código da roleta como a probabilidade é computada a partir do valor negativo do <em>fitness</em>. Já na seleção por torneio, o processo de seleção é bem mais simples como mostra a função <em>tournament()</em>. Na função, quatro individuos são escolhidos, pois <em>t.size = 4</em>, para competirem entre si. Aquele que dentre os quatro escolhidos tiver a menor aptidão (melhor) é selecionado para o cruzamento.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X2bIgE2Z0YD_J0TXCAaETw.png" /></figure><p>Em seguida toda a população intermediária escolhida é passada para a função de cruzamento (<em>simple.crossover()</em>) propriamente dita. No entanto, nem todos serão cruzados. Isso vai ser feito de acordo com a probabilidade de cruzamento (<em>Pc</em>), que normalmente é um valor entre 0.6 e 0.99, indicando a porcentagem média de indivíduos que serão cruzados por iteração. Especificamente nesta implementação estou usando <em>Pc = 0.6,</em> que implica que em média 60% dos indivíduos selecionados serão cruzados. Se o cruzamento será feito em ordem de posicionamento no vetor, aleatoriamente, ou de uma outra forma é uma decisão do programador. Eu decidi implementar a escolha aleatória dos genitores como pode ser visto na função <em>simple.crossover()</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LZZcZQ9nNfBWR3Ki_1oO3w.png" /></figure><p>Após realizar o cruzamento será necessário realizar a mutação, que é baseada na probabilidade de mutação (<em>Pm</em>), sendo normalmente um valor entre 0.01 e 0.05, ou seja, entre 1% e 5% de probabilidade de ser mutado. Aqui estou usando <em>Pm = 0.05</em>. A função <em>uniform.mutation()</em> realiza a mutação em todos os genes sem usar uma única instrução de laço. Após sua execução, utiliza-se a função <em>apply()</em> para avaliar a população resultante.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V6bPgS3hhoftavkPehbh8g.png" /></figure><p>Após a mutação chegamos no ponto onde o elitismo deve ou não ser utilizado. Como eu passei o parâmetro na função GA (<em>elitism = TRUE</em>), o mesmo será utilizado. No trecho de código apenas verifico se o melhor pai (geração corrente) é melhor que o melhor filho (nova geração). Em caso afirmativo, eu substituo o pior filho (que apresenta a pior aptidão) pelo melhor pai. Caso contrário não é necessário realizar a substituição. Assim, o processo é repetido até atingir o critério de parada.</p><p>Vamos executar o código em 4 versões: Roleta com elitismo, roleta sem elitismo, torneio com elitismo e torneio sem elitismo e ver os resultados para a função Rosenbrock em 5 execuções de cada, e usando os parâmetros previamente definidos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/977/1*za5tK5i1x-M4ZE87wzUUJQ.png" /></figure><p>Nitidamente, o elitismo fez diferença nos dois métodos de seleção, isto é, em ambos casos os resultados com elitismo foram melhores. Já em uma comparação superficial, o AG usando o método do torneio com elitismo apresentou os melhores resultados. Para uma comparação adequada métodos estatísticos deveriam ser utilizados, mas isso é assunto para outro post.</p><p>Bem chegamos ao fim. Espero que tenham gostado e que esse código seja útil para seus estudos e aprendizagem. A seguir indico alguns livros que podem ajudar a aumentar seus conhecimentos em AGs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/316/1*BTbIZtCkcXdwC0dN39hXLg.jpeg" /></figure><p>Este foi meu primeiro contato com Algoritmos Genéticos. Os primeiros capítulos são bem detalhados e mostram como um AG binário funciona passo a passo. Em seguida Michalewicz discute os motivos pelos quais os AGs funcionam e discute variações no algoritmo. A parte II é direcionada para a otimização numérica, na qual ele apresenta AGs em código real e como lidar com problemas com restrições. Possui um anexo com a implementação de um AG com código real em C.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/214/1*sT7NhorAMUwx1JeIsL7omQ.jpeg" /></figure><p>O livro de <a href="http://www.algoritmosgeneticos.com.br/">Ricardo Linden</a> discute o funcionamento de AGs de maneira bastante aprofundada, descrevendo diferentes métodos de seleção, cruzamento e mutação. Há um capítulo sobre a teoria de <em>schemas </em>e como eles estão presentes na evolução dos AGs binários. Além disso, ele discute os problemas que os operadores genéticos podem acarretar em determinados tipos de problemas. O livro todo apresenta implementações em Java que podem ser usadas para entender melhor os conceitos por ele apresentados.</p><p>Os códigos funcionando podem ser encontrados no endereço: <a href="https://gitlab.com/omar.carmona/real-coded-genetic-algorithm">https://gitlab.com/omar.carmona/real-coded-genetic-algorithm</a></p><p>Se usar os códigos por favor citar o seguinte artigo: “ Cortes, O. A. C. and Silva, J. C. (2019), Unconstrained numerical optimization using real-coded genetic algorithms: a study case using benchmark functions in R from Scratch. <em>Revista Brasileira De Computação Aplicada</em>, <em>11</em>(3), 1–11”.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=845219a56984" width="1" height="1" alt=""><hr><p><a href="https://medium.com/semper-evolutionis/implementado-algoritmos-gen%C3%A9ticos-em-r-845219a56984">Implementado Algoritmos Genéticos em R</a> was originally published in <a href="https://medium.com/semper-evolutionis">Semper Evolutionis</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>