SERVIÇO PÚBLICO FEDERAL
MINISTÉRIO DA EDUCAÇÃO
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO PARÁ
TECNOLOGIA EM A...
1
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO PARÁ
TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS
GASTÃO J...
2
INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO PARÁ
TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS
GASTÃO J...
3
RESUMO
Os problemas que envolvem processamento de grandes conjuntos de
dados, tem como solução o uso do modelo do proces...
4
ABSTRACT
The problems involving processing of large data sets, has as solution model
of parallel and distributed process...
5
LISTA DE ILUSTRAÇÕES
1 Figura 2.1: Ilustração das funções de ordem-superior map e fold, e
seu funcionamento.
15
2 Figura...
6
SUMARIO
1 INTRODUÇÃO ......................................................................................................
7
4.1.1 Indivíduos e a População.............................................................................................
8
1 INTRODUÇÃO
Vivemos na era dos dados. Não é fácil medir o volume total de dados
armazenados eletronicamente, mas uma es...
9
armazenamento é melhor resolvido no modelo do processamento paralelo e
distribuído, como o presentes em grid computacion...
10
distribui os dados em diversos nós de processamento e armazenamento; na
segunda etapa, o Reduce, que agrega e processa ...
11
desempenho quando implementada na técnica MapReduce, pois essa técnica não
suporta eficientemente aplicações iterativas...
12
Depois do levantamento da técnica e conceitos, foi desenvolvida uma
modelagem para implementar o algoritmo genético no ...
13
2 MODELO MAPREDUCE
O modelo de programação MapReduce é utilizado para o processamento de
grandes conjuntos de dados. É ...
14
de algoritmos mais simples, escondendo os detalhes da paralelização, tolerância a
falhas, distribuição de dados e balan...
15
Na medida em que elementos na lista posam ser divididos em grupos, a função fold
também pode prosseguir em paralelo. Re...
16
Para ser preciso, MapReduce pode referir-se a três conceitos distintos, mas
relacionados. Primeiro, MapReduce é um mode...
17
intermediários associados com a mesma chave e passa o resultado para a função
Reduce. A função Reduce, também escrita p...
18
2.2.1 Funcionamento
Os dados de entrada da função Map estão distribuídas em várias máquinas,
dividido automaticamente e...
19
ser atribuído, o mestre escolhe as máquinas ociosas e atribui a cada um delas uma
tarefa map ou reduce.
Operação (3): O...
20
armazena os endereços e os tamanhos das regiões de arquivo intermediário
produzidos pela tarefa map. Essas informações ...
21
ambiente de centenas ou milhares de máquinas. Para lidar com falhas das máquinas
escravas, o mestre se comunica com tod...
22
2.4.2 Apache Hadoop
Apache Hadoop é uma implementação de código aberto do MapReduce
implementado em Java, que permite o...
23
de mensagens, publicação/assinatura, para a comunicação e transferência de dados
e suporta longa duração de tarefas map...
24
2.4.6 CELL MapReduce
Cell MapReduce é uma implementação do modelo MapReduce escrito em C
para processador Cell. Este mo...
25
3 HADOOP
O Apache Hadoop, ou simplesmente Hadoop, é uma ferramenta para
processamento de grande quantidade de dados em ...
26
O NameNode gerencia os arquivos de metadados armazenados no HDFS
incluindo informações críticas, como a estrutura de di...
27
aplicação é executado apenas na máquina local, não sendo necessário usar o HDFS
para armazenar os arquivos. Esse modo é...
28
disco único na rede. Além disso, os blocos se encaixam bem com a replicação para
fornecer tolerância a falhas e disponi...
29
detalhes da paralelização, tolerância a falhas, distribuição de dados e
balanceamento.
3.3.1 Execução do Trabalho
Há qu...
30
Atribuição de tarefas: Tasktrackers executam um loop simples que envia
periodicamente chamadas Heartbeats1
para o JobTr...
31
mais simples envolve calcular o valor Hash da chave e, em seguida, tomar o resto
da divisão (mod) desse valor com o núm...
32
Figura 3.1. Shuffle e Sort em MapReduce (WHITE, 2010, p.178).
Antes de gravar no disco, ocorre uma divisão dos dados em...
33
map, os dados são fundidos e transferidos (Spill) para o disco. Como as cópias são
acumuladas no disco, é feito antecip...
34
Tabela 3.1: Representação do tipo primitivo Java em implementação do Writable.
Tipo Primitivo do Java Implementação Wri...
35
O framework executa os métodos da mesma forma que é executado na tarefa map,
porém o método reduce() é chamado uma vez ...
36
4 AG & PCV
O Algoritmo Genético (AG) é uma técnica de otimização utilizada como
busca global, empregada em situações na...
37
Este processo é constituído pelas seguintes etapas:
a) Inicialização: é a criação da população inicial para o primeiro ...
38
ser manipulado, e depende do tipo de problema e do que se deseja manipular pelo
algoritmo genético.
O AG usa nomenclatu...
39
4.1.2 Inicialização
A inicialização da população de um AG determina o processo de criação dos
indivíduos para o primeir...
40
A seleção opera de forma determinística, isto é, um indivíduo só consegue
sobreviver em um ambiente se for capaz de se ...
41
problema, na tentativa de chegar a soluções possíveis na qual o operador de
cruzamento não encontraria. As principais f...
42
veículos, a reformulação de motores de turbinas em aeronaves e otimização das
tarefas de máquinas industriais (GUTIN, 2...
43
Tabela 4.1: Números possíveis de caminho em função do número de cidades no
problema do caixeiro viajante simétrico (PCV...
44
Heurísticas PCV ou Algoritmos de Aproximação PCV é aplicado se houver
alguma garantia de aproximação, aplicado quando o...
45
Figura 4.3: Codificação da “Representação Matricial”.
Outro método é o sequenciamento de caracteres4
de duas maneiras
d...
46
4.2.2 Aptidão
A avaliação do indivíduo é realizada através de uma função que representa
o problema, fornecendo uma medi...
47
Figura 4.5: Funcionamento do operador PMX.
Este cruzamento é mais adequado quando é usado com a representação da
Notaçã...
48
Figura 4.6: Funcionamento do operador CX.
Este cruzamento é mais adequado com a representação de Sequência
Ordenada. Es...
49
Figura 4.7: Funcionamento do operador OX.
Este cruzamento é mais adequado quando é usado com a representação de
Sequênc...
50
dois pontos de inversão no cromossomo e em seguida, inverte-se a ordem dos
genes entre os dois pontos.
Há também operad...
51
5 IMPLEMENTAÇÃO
Os Algoritmos Genéticos possuem características que não permitem ser
exatamente expressa no modelo MapR...
52
Considerando que a técnica MapReduce não fornece suporte eficiente para
as aplicações iterativas, algumas melhorias for...
53
as iterações do algoritmo ocorrem sobre a memória principal das máquinas
presentes na rede de computadores. Na Tabela 5...
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”
Próximos SlideShares
Carregando em…5
×

Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”

629 visualizações

Publicada em

Trabalho Acadêmico de Conclusão de Curso apresentado ao Colegiado Específico de TADS do Instituto Federal de Educação, Ciência e Tecnologia do Pará – IFPA.

Publicada em: Tecnologia
0 comentários
2 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

Sem downloads
Visualizações
Visualizações totais
629
No SlideShare
0
A partir de incorporações
0
Número de incorporações
3
Ações
Compartilhamentos
0
Downloads
9
Comentários
0
Gostaram
2
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Aplicação da Técnica Mapreduce na Modelagem de Algoritmos Genéticos para o “Problema do Caixeiro Viajante”

  1. 1. SERVIÇO PÚBLICO FEDERAL MINISTÉRIO DA EDUCAÇÃO INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO PARÁ TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS GASTÃO JOSE MACEDO CLAUDE WESLEY LOUZEIRO MOTA APLICAÇÃO DA TÉCNICA MAPREDUCE NA MODELAGEM DE ALGORITMOS GENÉTICOS PARA O “PROBLEMA DO CAIXEIRO VIAJANTE” BELÉM 2014
  2. 2. 1 INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO PARÁ TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS GASTÃO JOSE MACEDO CLAUDE WESLEY LOUZEIRO MOTA APLICAÇÃO DA TÉCNICA MAPREDUCE NA MODELAGEM DE ALGORITMOS GENÉTICOS PARA O “PROBLEMA DO CAIXEIRO VIAJANTE” . Trabalho Acadêmico de Conclusão de Curso apresentado ao Colegiado Específico de TADS do Instituto Federal de Educação, Ciência e Tecnologia do Pará – IFPA, como requisito para a obtenção do Grau em Tecnologia em Análise e Desenvolvimento de Sistemas, sob a orientação do Prof. Ms. Claudio Roberto de Lima Martins. BELÉM 2014
  3. 3. 2 INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO PARÁ TECNOLOGIA EM ANÁLISE E DESENVOLVIMENTO DE SISTEMAS GASTÃO JOSE MACEDO CLAUDE WESLEY LOUZEIRO MOTA APLICAÇÃO DA TÉCNICA MAPREDUCE NA MODELAGEM DE ALGORITMOS GENÉTICOS PARA O “PROBLEMA DO CAIXEIRO VIAJANTE” Data Defesa: ___ /___/___ Conceito:______________ Banca Examinadora . _______________________________________ Profº. Orientador: Msc. Claudio Roberto de Lima Martins – IFPA _______________________________________ Profº. Msc. Fabrício Medeiros Alho – IFPA _______________________________________ Profº. Msc. Márcio Góes do Nascimento – IFPA BELÉM 2014
  4. 4. 3 RESUMO Os problemas que envolvem processamento de grandes conjuntos de dados, tem como solução o uso do modelo do processamento paralelo e distribuído, que se adapta a qualquer volume e nível de processamento. Esse é o caso do MapReduce, uma técnica que abstrai os detalhes de paralelização do algoritmo de execução para o processamento de grandes conjuntos de dados, tornando-se adequado na aplicação dos Algoritmos Genéticos (AG), técnicas de otimização aplicadas em domínios como inteligência artificial, otimização numérica e combinatória. Neste trabalho é demonstrada a aplicação da técnica MapReduce na modelagem do Algoritmo Genético para resolver o Problema do Caixeiro Viajante, um problema que tenta determinar a menor rota para percorrer uma série de cidades (visitando cada uma pelo menos uma vez). É realizado um levantamento das técnicas, conceitos e modelos, e com base nisso é proposto uma nova modelagem do Algoritmo Genético para o MapReduce na tecnologia Apache Hadoop. A proposta é fundamentada nas melhores características apresentadas por outros modelos, melhorando o seu desempenho e simplificando o seu desenvolvimento. A avaliação é baseada na simulação da aplicação e no desempenho do modelo sobre a variação do tamanho dos dados de processamento. Os resultados demonstram que o modelo proposto é eficiente no processamento de grande quantidade de dados, pois comprova-se que o aumento do tamanho dos dados iniciais da aplicação tende a encontrar as melhores soluções. PALAVRAS-CHAVE: MapReduce; Hadoop; Algoritmos Genéticos; Problema do Caixeiro Viajante.
  5. 5. 4 ABSTRACT The problems involving processing of large data sets, has as solution model of parallel and distributed processing, which adapts to any volume and level of processing. This is the case of MapReduce, a technique that abstracts the details of parallelization of the execution algorithm for processing of large data sets, making it suitable in the application of Genetic Algorithms (GA) optimization techniques applied in fields such as artificial intelligence, numerical optimization, and Combinatorics. In this work is demonstrated the application of MapReduce technique on modeling the genetic algorithm to solve the Travelling Salesman Problem, a problem that attempts to determine the shortest route to traverse a series of cities (visiting each one at least once). Is performed a survey of techniques, concepts and models, and on this basis it is proposed a new modeling of Genetic Algorithm for the MapReduce in the Apache Hadoop technology. The proposal is grounded on the best features presented by other models, improving performance and simplifying its development. The evaluation is based on simulations of application and performance of the model on the variation of the size of the data processing. The results demonstrate that the proposed model is efficient in processing large amounts of data, because it proves that the increase in the size of the initial data from the application tends to find the best solutions. KEY-WORDS: MapReduce, Hadoop, Genetic Algorithm, Traveling Salesman Problem
  6. 6. 5 LISTA DE ILUSTRAÇÕES 1 Figura 2.1: Ilustração das funções de ordem-superior map e fold, e seu funcionamento. 15 2 Figura 2.2: Vista simplificada do funcionamento de um trabalho MapReduce. 17 3 Figura 2.3: Fluxo de uma operação do modelo MapReduce. 18 4 Figura 3.2. Shuffle e Sort em MapReduce. 32 5 Figura 4.1. Detalhe do indivíduo AG. 38 6 Figura 4.2: Grafo completo no plano Euclidiano. 42 7 Figura 4.3: Codificação da “Representação Matricial”. 45 8 Figura 4.4: Codificação “sequencial”: a) Sequência Ordenada; b) Notação do Ciclo. 45 9 Figura 4.5: Funcionamento do operador PMX. 47 10 Figura 4.6: Funcionamento do operador CX. 48 11 Figura 4.7: Funcionamento do operador OX. 49 12 Figura 5.1: Mapa das cidades do PCVS no plano euclidiano. 55 13 Figura 5.2: Exemplo do cálculo da distância entre as cidades. 56 14 Figura 5.3: Funcionamento do processamento MapReduce para o Algoritmo Genético no modelo Dupla Geração. 59 15 Figura 5.4: Fluxo lógico de dados do processo MapReduce para o AG. 61 16 Figura 5.5: Código Map do Algoritmo Genético MapReduce. 63 17 Figura 5.6: Código Reduce do Algoritmo Genético MapReduce. 64 18 Figura 5.7: Diagrama de classe do PCV-AG para o MapReduce. 65 19 Figura 5.8: Código simplificado da classe Indivíduo. 66 20 Figura 5.9: Código simplificado da classe CaixeiroViajanteMapper. 66 21 Figura 5.10: Código simplificado da classe CaixeiroViajanteReducer. 67 22 Figura 5.11: Código simplificado da classe OperacaoGenetica. 68 23 Figura 5.12: Mapa do conjunto de 20 cidades no plano euclidiano. 70 24 Figura 5.13: Tendência gerada pelo aumento de escala da população. 72 25 Figura 5.14: Melhor e pior indivíduo encontrado entre os melhores. 73
  7. 7. 6 SUMARIO 1 INTRODUÇÃO ........................................................................................................................8 1.1 OBJETIVO ......................................................................................................................... 11 1.1.1 Objetivo Geral.................................................................................................................. 11 1.1.2 Objetivo Especifico.......................................................................................................... 11 1.2 METODOLOGIA................................................................................................................. 11 1.3 ESTRUTURA DO TEXTO ..................................................................................................12 2 MODELO MAPREDUCE.......................................................................................................13 2.1 INTRODUÇÃO.................................................................................................................... 13 2.2 MAPREDUCE..................................................................................................................... 16 2.2.1 Funcionamento................................................................................................................ 18 2.3 FRAMEWORK DE EXECUÇÃO MAPREDUCE................................................................ 20 2.4 IMPLEMENTAÇÃO ............................................................................................................ 21 2.4.1 Google MapReduce......................................................................................................... 21 2.4.2 Apache Hadoop............................................................................................................... 22 2.4.3 Twister ............................................................................................................................. 22 2.4.4 Phoenix............................................................................................................................ 23 2.4.5 Mars .................................................................................................................................23 2.4.6 CELL MapReduce ........................................................................................................... 24 2.4.7 MRPGA............................................................................................................................ 24 2.5 CONCLUSÃO ..................................................................................................................... 24 3 HADOOP...............................................................................................................................25 3.1 INTRODUÇÃO.................................................................................................................... 25 3.1.1 Componentes .................................................................................................................. 25 3.1.2 Modo de Execução.......................................................................................................... 26 3.2 HDFS ..................................................................................................................................27 3.3 FRAMEWORK MAPREDUCE............................................................................................ 28 3.3.1 Execução do Trabalho ....................................................................................................29 3.3.2 Partitioners e Combiners.................................................................................................30 3.3.3 Shuffle e Sort................................................................................................................... 31 3.3.4 Aplicações ....................................................................................................................... 33 3.4 CONCLUSÃO ..................................................................................................................... 35 4 AG & PCV..............................................................................................................................36 4.1 ALGORITMOS GENÉTICOS ............................................................................................. 36
  8. 8. 7 4.1.1 Indivíduos e a População................................................................................................ 37 4.1.2 Inicialização ..................................................................................................................... 39 4.1.3 Processo de Avaliação e Seleção................................................................................... 39 4.1.4 Processo de Cruzamento e Mutação.............................................................................. 40 4.1.5 Processo de Atualização e Finalização.......................................................................... 41 4.2 PROBLEMA DO CAIXEIRO VIAJANTE ............................................................................ 41 4.2.1 Codificação...................................................................................................................... 44 4.2.2 Aptidão............................................................................................................................. 46 4.2.3 Operadores de cruzamento............................................................................................. 46 4.2.4 Operadores de mutação..................................................................................................49 4.3 CONCLUSÃO ..................................................................................................................... 50 5 IMPLEMENTAÇÃO ...............................................................................................................51 5.1 TRABALHOS RELACIONADOS........................................................................................ 51 5.2 MODELO AG EM MAPREDUCE....................................................................................... 52 5.3 MODELAGEM DO PROBLEMA ........................................................................................ 54 5.3.1 Modelagem do Algoritmo Genético................................................................................. 56 5.3.2 Modelagem do MapReduce ............................................................................................ 58 5.4 IMPLEMENTAÇÃO ............................................................................................................ 61 5.4.1 Algoritmo.......................................................................................................................... 61 5.4.2 Implementação em Java .................................................................................................65 5.5 TESTES E AVALIAÇÃO DE RESULTADOS.....................................................................69 5.5.1 Ambiente operacional e cenário de execução................................................................ 69 5.5.2 Simulações e resultados obtidos .................................................................................... 71 5.5.3 Desempenho da Modelagem Dupla Geração ................................................................ 73 5.6 CONSIDERAÇÕES FINAIS ............................................................................................... 74 CONCLUSÃO...........................................................................................................................78 REFERÊNCIAS BIBLIOGRÁFICAS .......................................................................................81 ANEXO A..................................................................................................................................84
  9. 9. 8 1 INTRODUÇÃO Vivemos na era dos dados. Não é fácil medir o volume total de dados armazenados eletronicamente, mas uma estimativa da IDC (EMC, 2014) colocou o tamanho do "universo digital" em ordem do zetabytes, fenômeno chamado de Big Data (aqui denominado com BigData). Há uma grande quantidade de dados, a maioria dos dados está contida nas maiores propriedades da web, ou instituições científicas ou financeiras. A New York Stock Exchange, Facebook, Ancestry.com, O Large Hadron Collider (LHC), trabalha ou armazena dados que vai de terabytes a petabytes (WHITE, 2010). Atualmente há vários exemplos de aplicações sobre o BigData. Por exemplo, a análise dos dados sobre o comportamento do usuário web recuperados de sistemas de vendas na web e redes sociais. O registro do comportamento gera uma quantidade de dados que muitas organizações simplesmente não conseguem lidar com o volume, levando ao descarte desses dados depois de algum tempo. Isto representa perda de oportunidades. Conhecer o comportamento dos usuários permite melhores decisões de negócios e uma vantagem competitiva no mercado. Em termos gerais, isso é conhecido como inteligência de negócios, que abrange uma ampla variedade de tecnologias, incluindo data warehousing, data mining e analytics (LIN & DYER, 2010). O BigData é um conceito definido para um conjunto de dados extremamente grande, gerado pelo crescimento do poder computacional e do surgimento de novas fontes geradoras de informação, tornando-se um desafio na área de Tecnologia da Informação. O BigData deve tratar de pelo menos três propriedades: volume, velocidade, variedade. O volume está associado ao sistema de armazenamento que extrapola os valores tradicionais a ser armazenado. A velocidade está relacionado ao processamento e à rapidez no acesso aos dados. A variedade diz respeito à diversidade do formato e da estrutura de armazenamento dos dados de origem. Portanto a solução para o BigData deve possuir a característica de escalabilidade para suprir todas as sua propriedades. Soluções convencionais, como banco de dados relacional, não conseguem atender questões que envolvem o Volume e a Velocidade, pois o poder de processamento, de capacidade e
  10. 10. 9 armazenamento é melhor resolvido no modelo do processamento paralelo e distribuído, como o presentes em grid computacional, tornado assim adaptável a qualquer volume em nível de processamento. Mas, empregar o paradigma de paralelização da computação, com distribuição dos dados, não é trivial. Aspectos envolvidos com a paralelização, tolerância a falhas, distribuição de dados e balanceamento de carga devem ser levados em conta pelo desenvolvedor de aplicações (DEAN & GHEMAWAT, 2008). O programador tem que pensar nas falhas da implementação, na reprogramação e substituição de máquinas defeituosas, coordenar os processos da computação distribuída em larga escala, saber se um processo remoto falhou ou não, enfim, um grande desafio a superar. Como solução para esses problemas e desafios, foi proposto o modelo MapReduce de programação, para ser executado em um grid computacional. Como a solução para o BigData está relacionada com escalabilidade, MapReduce extrai a dificuldade de programação do grid computacional, provendo suporte às propriedades do BigData. A velocidade é resolvida com as escalabilidade do processamento do MapReduce, baseado em cada processador dos nós que fazem parte do grid; se houver necessidade de aumentar a velocidade de resposta, basta aumenta o número de máquinas no arranjo do grid. O Volume é resolvido com a escalabilidade do sistema de armazenamento distribuído do MapReduce; para mais volume, mais máquinas podem ser adicionadas para a utilização do disco rígido em cada nó, sem prejudicar o sistema, tornado-se bem flexível. A Variedade é resolvida com a utilização de Banco de Dados com tecnologias específicas para o modelo, como o NoSQL, que fornece suporte a estrutura "chave/valor", um esquema altamente escalavel para a manipulação de grandes bases de dados em formatos diversos. MapReduce é um modelo de programação baseado em duas funções chamadas map e reduce, inspiradas em linguagens funcionais. Esse modelo estabelece uma abstração que permite construir aplicações com operações simples, escondendo os detalhes da paralelização. Em resumo, tais funções utilizam um conjunto de pares chave/valor para entrada e saída dos dados. O modelo MapReduce divide o processamento em duas etapas. Na primeira o Map, mapeia e
  11. 11. 10 distribui os dados em diversos nós de processamento e armazenamento; na segunda etapa, o Reduce, que agrega e processa os resultados principais, para gerar um resultado final. O poder computacional da técnica MapReduce pode ser aplicado em vários campos, como o agrupamento de dados, aprendizado de máquina e visão computacional. Um desses casos são os Algoritmos Genéticos na qual tende a encontra valores de alta aptidão com o aumento na escala do número de indivíduos da população, porém esse aumento levaria um alto custo de processamento, tornado a técnica MapReduce ideal. Os Algoritmos Genéticos são aplicados em vários domínios, tais como, no campo da inteligência artificial, otimização numérica e combinatória, engenharia, química, biologia e etc. Os Algoritmos Genéticos mais simples necessitam de uma grande população para encontrar uma boa solução, essa grande quantidade de dados podem afetar o desempenho da máquina, pois dependendo do problema exigiria grande quantidade de memória e de processamento, tornando impossível para uma só máquina. Sendo os Algoritmos Genéticos um algoritmo de natureza paralela ele pode ser processado em várias máquinas, porém isso demandaria que o algoritmo implementasse todas as rotinas necessárias para a paralelização em ambiente distribuído, tornado-o mais complexo. O MapReduce é uma técnica para abstrair os detalhes de paralelização do algoritmo de execução, tornando adequado para a necessidade dos Algoritmos Genéticos podendo escalar grande quantidade de indivíduos e reduzir o tempo de execução. O Algoritmo Genético é uma técnica de otimização utilizada como um método de busca, podendo ser aplicada em situações que o número valores ou combinações para resolver um determinado problema são muito alto como é caso Problema do Caixeiro Viajante (PCV), em que o número de combinações de caminhos aumenta exponencialmente em função do número de cidades. O PCV é um problema de otimização NP-difícil, que consiste em encontrar o menor caminho para um caixeiro viajante que visita várias cidades apenas uma vez, e tem diferentes aplicações, como problema de roteamento de veículos e a otimização das tarefas de máquinas industriais. No trabalho de Verma et al.(2009), foi proposto uma forma de modelar as iterações dos algoritmos genéticos, porém essa modelagem tem um alto custo de
  12. 12. 11 desempenho quando implementada na técnica MapReduce, pois essa técnica não suporta eficientemente aplicações iterativas. Para resolver esse problema de desempenho, foi desenvolvida novas formas de modelar os Algoritmos Genéticos para a técnica MapReduce, com objetivo de minimizar o custo de desempenho. 1.1 OBJETIVO 1.1.1 Objetivo Geral O objetivo deste trabalho é demonstrar o uso da técnica MapReduce na modelagem de algoritmos genéticos. Para isso, será demonstrado a implementação de uma aplicação que busque a otimização para a melhor solução ao problema conhecido por "caixeiro viajante". 1.1.2 Objetivo Especifico Pesquisar conceitos, técnicas e ferramentas para o desenvolvimento de aplicações distribuídas para processamento paralelo e massivo de dados. Apresentar o modelo MapReduce de programação. Demonstrar uma implementação MapReduce para armazenamento, manipulação e análise de dados. Apresentar o Algoritmo Genético e seu processo de funcionamento. Apresentar o conceito do Problema do Caixeiro Viajante e os métodos dos Algoritmos Genéticos específicos para esse problema. Demonstrar as formas de modelar os Algoritmos Genéticos e sua implementação para Framework Hadoop. Avaliar os resultados do modelo e da aplicação utilizada para resolver o Problema do Caixeiro Viajante. 1.2 METODOLOGIA Neste trabalho foi feita uma pesquisa bibliográfica de documentos relevantes sobre a tecnologia do BigData, do modelo de programação MapReduce, do Framework Hadoop, sobre o Algoritmos Genético e, especialmente, ao problema do "Caixeiro Viajante".
  13. 13. 12 Depois do levantamento da técnica e conceitos, foi desenvolvida uma modelagem para implementar o algoritmo genético no MapReduce, para resolver o problema do "caixeiro viajante". Foi realizada uma avaliação dos resultados obtidos na simulação da aplicação quanto a melhor solução otimizada, considerando o tamanho da população do AG, isto é, uma análise sobre a variação da quantidade de dados que servem de parâmetros para busca da melhor solução. 1.3 ESTRUTURA DO TEXTO O trabalho está organizado da seguinte forma. No capítulo 2 apresenta o modelo de programação MapReduce, seus conceitos, características, funcionamento e implementações. No capítulo 3 é apresentada a implementação MapReduce, o Apache Hadoop, sua estrutura, características e componentes, em especial o HDFS e o framwork Hadoop MapReduce. No capítulo 4, apresenta-se a técnica do Algoritmo Genético e o Problema do Caixeiro Viajante. No capítulo 5 é apresentada a modelagem do Algoritmo Genético no modelo de programação MapReduce para o Problema do Caixeiro Viajante, além de sua implementação no Apache Hadoop, e relatados os resultados obtidos na simulação do algoritmo e as considerações finais.
  14. 14. 13 2 MODELO MAPREDUCE O modelo de programação MapReduce é utilizado para o processamento de grandes conjuntos de dados. É baseado no ambiente computacional paralelo e distribuído, provendo escalabilidade e simplificação para o desenvolvimento das aplicações para o BigData. Embora MapReduce proporcione facilidades no processamento do BigData, as aplicações devem se projetadas como é proposto no modelo de programação funcional, exigindo um estudo mais detalhado sobre o domínio da aplicação, verificando-se se ela se adéqua ao modelo MapReduce. Este capítulo apresenta a técnica MapReduce. Na seção 2.1 é apresentada uma visão geral do modelo. Na seção 2.2, o modelo MapReduce é definido em termos de seu funcionamento. Na seção 2.3 apresentamos as características de execução do MapReduce. Na seção 2.4 apresentamos as implementações do MapReduce disponíveis no mercado. Finalizamos com a conclusão do capítulo na seção 2.5. 2.1 INTRODUÇÃO O MapReduce foi originalmente desenvolvido pela Google no início dos anos 2000, no qual se buscava aperfeiçoar o serviço de busca de páginas Web, almejando criar uma melhor técnica para processar e analisar regularmente o imenso conjunto de dados da Web (GOLDMAN et al., 2012, p. 3). Para o processamento de grande quantidade de dados, há necessidade que o processamento seja distribuído entre centenas ou milhares de máquinas, configuração que permite diminuir o tempo desse processamento. As questões de como paralelizar a computação, distribuir os dados, e identificar as falhas, dificultam a computação simples, levando o programador a lidar com grande quantidade de código complexo (DEAN & GHEMAWAT, 2008, p. 1). Com o objetivo de resolver esta complexidade, Jeffrey Dean e Sanjay Ghemawat, dois engenheiros da Google, desenvolveram a tecnologia MapReduce inspirada nas funções map e reduce presentes na linguagem de programação Lisp e em muitas outras linguagens funcionais. Essa nova abstração permitiu a execução
  15. 15. 14 de algoritmos mais simples, escondendo os detalhes da paralelização, tolerância a falhas, distribuição de dados e balanceamento de carga em uma biblioteca criada para essa finalidade (DEAN & GHEMAWAT, 2008, p. 1). Deste modo, possibilitou otimizar a indexação e catalogação dos dados sobre as páginas Web e suas ligações. O MapReduce permite dividir um grande problema em vários pedaços e distribuí-los em diversos computadores. Essa técnica deixou o sistema de busca do Google mais rápido mesmo sendo executado em computadores convencionais e menos confiáveis, diminuindo assim os custos ligados à infraestrutura (GOLDMAN et al., 2012, p. 3). MapReduce tem suas raízes em programação funcional. Uma característica chave de linguagens funcionais é o conceito de funções de ordem-superior (higher- order), ou funções que podem aceitar outras funções como argumentos. Duas funções comuns de ordem superior são map e fold. Por exemplo, dada uma lista conforme vista na Figura 2.1, a função superior map utiliza a função f, que recebe como parâmetros todos os elementos da lista. A lista resultante da função map é utilizada pela função superior fold, que combina os valores da lista através da função g. A função g usa um valor inicial e o primeiro item da lista, o resultado é armazenado em uma variável intermediária. Na segunda execução, g utiliza a variável intermediária e o próximo item da lista. Este processo se repete até que todos os itens da lista tenham sido processados, retornando no final o valor da variável intermediária (LIN & DYER, 2010, p. 20). Podemos ver map como uma forma concisa para representar a transformação de um conjunto de dados, como definido pela função f. Na mesma linha, podemos ver fold como uma operação de agregação, como definido pela função g. Uma observação imediata é que a aplicação de f para cada item em uma lista pode ser paralelizado de uma maneira simples, uma vez que cada aplicação funcional acontece isoladamente. Em um cluster de máquinas, estas operações podem ser distribuídas em diferentes máquinas. A operação de fold, por outro lado, tem mais restrições quanto à localidade dos dados, pois os elementos da lista devem ser reunidos para serem aplicados na função g. No entanto, muitas aplicações não exigem que a função g seja aplicada a todos os elementos da lista.
  16. 16. 15 Na medida em que elementos na lista posam ser divididos em grupos, a função fold também pode prosseguir em paralelo. Resumidamente, descrevemos a técnica MapReduce, em que suas fases Map e Reduce correspondam aproximadamente às operação map e fold da programação funcional (LIN & DYER, 2010, p. 20). Figura 2.1: Ilustração das funções de ordem-superior map e fold, e seu funcionamento (Adaptado de: LIN & DYER, 2010, p. 20). Visto de um ângulo diferente, MapReduce pode ser aplicado como uma receita genérica para processamento de grandes conjuntos de dados, organizado em duas fases que correspondem às duas funções do MapReduce. No primeiro estágio, uma computação é aplicada paralelamente sobre todos os registros de entrada de um conjunto de dados, produzindo uma saída intermediária que é então agregada por uma computação na segunda fase (LIN & DYER, 2010, p. 21). O par chave/valor é a estrutura básica de dados no MapReduce. Os algoritmos devem levar um conjunto de pares chave/valor de entrada e produzir um conjunto de pares chave/valor de saída. O usuário da biblioteca do MapReduce modela o algoritmo como duas funções Map e Reduce. O Map leva um par de entradas e produz um conjunto de pares chave/valor intermediários, que em seguida são agrupados de acordo com a chave e passa para a função de Reduce. A função reduce, aceita uma chave intermediária e seu conjunto de valores. Ela mescla esses valores para formar um conjunto possivelmente menor de valores (DEAN & GHEMAWAT, 2008, p. 1). f f f f f g g g g g Lista usada no map Lista resultante do map Lista usada no fold Valor Inicial Valor Final Variável Intermediária Função f Função g
  17. 17. 16 Para ser preciso, MapReduce pode referir-se a três conceitos distintos, mas relacionados. Primeiro, MapReduce é um modelo de programação. Segundo, MapReduce pode referir-se ao framework de execução, que coordena a execução de programas escritos neste estilo particular de tecnologia. Finalmente, MapReduce pode se referir à implementação de software do modelo de programação e do framework de execução, como é o caso das várias implementação existentes, como a ferramenta proprietária do Google, e a solução em código aberto do Hadoop, para processadores multicore (Phoenix) e etc. (LIN & DYER, 2010, p. 21). 2.2 MAPREDUCE Como visto, MapReduce é um modelo de programação especificado em funções map e reduce. Pares de chave/valor formam a estrutura básica de dados em MapReduce. Parte do projeto de algoritmos MapReduce envolve impor a estrutura de chave/valor em conjuntos de dados com qualquer tipo de dado (inteiro, texto, etc). Em alguns algoritmos, as chaves de entrada não são particularmente significativas e são simplesmente ignoradas durante o processamento, enquanto em outros casos chaves de entrada são usados para identificar exclusivamente um dado (LIN & DYER, 2010, p. 22). Em MapReduce, o programador define a função map e a função reduce com as seguintes assinaturas (onde [ e ] representam uma lista de valores) : map: (k1, v1)  [(k2, v2)] reduce: (k2, [v2])  [(k3, v3)] A entrada para um trabalho MapReduce começa com os dados armazenados no sistema de arquivos distribuído. Como podemos ver na Figura 2.2, os algoritmos devem levar um conjunto de pares chave/valor de entrada e produzir um conjunto de pares chave/valor de saída. O usuário (programador) da biblioteca MapReduce modela o algoritmo como duas funções Map e Reduce. O Map escrito pelo programador leva um par de entradas e produz um conjunto de pares chave/valor intermediários. Posteriormente, são unidos todos os valores
  18. 18. 17 intermediários associados com a mesma chave e passa o resultado para a função Reduce. A função Reduce, também escrita pelo programador, aceita uma chave intermediária e seu conjunto de valores. A função Reduce mescla esses valores para formar um conjunto possivelmente menor de valores (DEAN & GHEMAWAT, 2008, p. 1). Os dados intermediários chegam a cada redutor em ordem, classificadas pela chave, no entanto, nenhuma relação de ordenação é garantida para chaves através de diferentes redutores. Pares chave/valor de saída de cada redutor são escritos persistentemente no sistema de arquivos distribuído enquanto que pares de chave/valor intermediários são transitórios e não preservados. A saída termina em vários arquivos no sistema de arquivos distribuído, em que corresponde ao número de redutores (LIN & DYER, 2010, p. 22). Figura 2.2: Vista simplificada do funcionamento de um trabalho MapReduce (Adaptado de: LIN & DYER, 2010, p. 23). K1 V1 K1 V1 K1 V1 K1 V1 reducer reducer reducer K2 V2 K2 V2 K2 V2 K2 V2 K3 V3 Shuffle e Sort: Agregação de Valores por Chaves K2 [V2] K2 [V2] K2 [V2] mapper mapper mapper mapper K3 V3 K3 V3
  19. 19. 18 2.2.1 Funcionamento Os dados de entrada da função Map estão distribuídas em várias máquinas, dividido automaticamente em um conjunto de M divisões, que podem ser processadas em paralelo por máquinas diferentes. Os dados de entrada da função Reduce estão distribuída em R partições do espaço intermediário. A Figura 2.3 mostra o fluxo total de uma operação MapReduce. Quando o programa do usuário (programador) chama a função MapReduce, ocorre a seguinte sequência de ações (DEAN & GHEMAWAT, 2008, p. 2). Figura 2.3: Fluxo de uma operação do modelo MapReduce (Adaptado de: DEAN & GHEMAWAT, 2008, p. 3). Operação (1): Primeiramente a biblioteca do MapReduce divide os arquivos de entrada em M blocos de tamanho fixo na casa das dezenas de MB por bloco de dados. Em seguida começa as cópias do programa em um cluster de máquinas. Operação (2): Um das cópias do programa é o mestre e o restante são os escravos, que recebem tarefas do mestre. Há M tarefas map e R tarefas reduce para Arquivos de entrada Fase de Map Fase de Reduce Arquivos de saída Arquivos Intermediários (em disco local) Programa de usuário Mestre Escravo Escravo Escravo Escravo Escravo Bloco 0 Bloco 1 Bloco 2 Bloco 3 Bloco 4 Arquivo de saída0 Arquivo de saída1 (1) Replicação (1) Replicação (1) Replicação (2) Tarefa map (2) Tarefa reduce (4) Escrita local (3) Leitura (6) Escrita (5) Leitura remota
  20. 20. 19 ser atribuído, o mestre escolhe as máquinas ociosas e atribui a cada um delas uma tarefa map ou reduce. Operação (3): O escravo que executa uma tarefa map lê o conteúdo do bloco de entrada e analisa os pares chave/valor encontrados, passando-os para a função map definida pelo usuário. A função map produz os pares chave/valor intermediários, que são armazenados em buffer na memória. Operação (4): Periodicamente, os pares em buffer são gravados no disco local, dividido em R regiões pela função de particionamento. Os endereços desses pares no disco local são passados para o mestre, que é responsável por encaminhar esses endereços para os escravos reduce. Operação (5): Quando um escravo reduce é notificado pelo mestre sobre esses endereços, ele usa chamadas de procedimento remoto para ler os dados do disco local de cada escravo map. Quando um escravo reduce tem que ler todos os dados intermediários para sua partição, ele classifica os dados pela chave para que todos os valores que têm a mesma chave sejam agrupados juntos. Operação (6): O escravo reduce itera sobre os dados classificados e para cada chave intermediária única, ele passa a chave e o conjunto correspondente de valores intermediários para a função reduce do usuário. A saída da função de reduce é anexada a um arquivo de saída final para cada partição do reduce. Operação (7): Quando todas as tarefas map e reduce forem concluídas, o mestre reativa o programa do usuário para a recuperação do resultado final. Após a conclusão, a saída da execução do MapReduce está disponível em R arquivos de saída. Normalmente, os programadores não precisam combinar esses arquivos em um único arquivo, pois muitas vezes eles são usados como entrada para outra trabalho MapReduce ou são usados para outro aplicativo distribuído (DEAN & GHEMAWAT, 2008, p. 3). Para cada tarefa map e reduce, o mestre armazena o estado (ocioso, em andamento ou concluído) e a identidade da máquina escravo. O mestre é o canal através do qual a localização das regiões de arquivo intermediário é transferida das tarefas map para as tarefas reduce. Antes, para cada tarefa map concluída, o mestre
  21. 21. 20 armazena os endereços e os tamanhos das regiões de arquivo intermediário produzidos pela tarefa map. Essas informações são recebidas quando as tarefas map são concluídas e é enviada incrementalmente para o escravo que tem em andamento as tarefas reduce (DEAN & GHEMAWAT, 2008, p. 3). 2.3 FRAMEWORK DE EXECUÇÃO MAPREDUCE O MapReduce separa os algoritmos de execução dos detalhes do sistema paralelo e distribuído, como a distribuição de dados, o balanceamento de carga, o tratamento de falhas entre outros. Um programa MapReduce, é referido como um trabalho (work), consistindo em um código para fase Map, um código para fase Reduce e mais os parâmetros de configuração. O desenvolvedor envia o trabalho para um nó mestre do cluster e o framework de execução (runtime) cuida de tudo (LIN & DYER, 2010, p. 26). Cada trabalho MapReduce é dividido em unidades menores chamadas de tarefas (job). Existem trabalhos que têm milhares de tarefas que precisam ser atribuídas ao cluster. Em muitos casos o número das tarefas é maior que o número de máquinas em um cluster, levando o framework definir a ordem de prioridade de execução das tarefas. A ideia do MapReduce é mover o código e não os dados. O agendador de tarefas localiza as máquinas que têm os dados para ser processados, se isso não for possível, as novas tarefas serão iniciadas em outros lugares e os dados necessários serão transmitidos através da rede (LIN & DYER, 2010, p. 26- 27). Em MapReduce , a sincronização é realizada entre a fases Map e Reduce. A tarefa reduce não pode começar antes que todas as emissões dos pares chave/valor das tarefas map tenham sido concluídas e que todos os pares chave/valor intermediários tenham sido transferidos, agrupados e classificados (LIN & DYER, 2010, p. 27-28). O framework de execução MapReduce deve realizar todas as tarefas anteriores em um ambiente onde os erros e falhas são frequentes. A biblioteca MapReduce é projetada para tolerar falhas de máquina com elegância em uma
  22. 22. 21 ambiente de centenas ou milhares de máquinas. Para lidar com falhas das máquinas escravas, o mestre se comunica com todos os escravos periodicamente, se nenhuma resposta for recebida em um determinado período de tempo, o mestre marca o escravo como “falho”. Com isso, qualquer tarefa map ou reduce em andamento é reagendamento para outra máquina (DEAN & GHEMAWAT, 2008, p. 3). 2.4 IMPLEMENTAÇÃO Implementação MapReduce pode se referir a implementação de software do modelo de programação e do framework de execução. Muitas implementações diferentes do modelo de programação MapReduce são possíveis, dependendo somente do ambiente (DEAN & GHEMAWAT, 2008, p. 2). Já existem várias implementações do modelo, mantendo ou não a mesma abstração básica, mas suas capacidades variam consideravelmente. Entre elas foram desenvolvidas várias implementações de código fonte aberto, mantido pela comunidade de software livre, destacando-se o Apache Hadoop, que é utilizado neste trabalho. 2.4.1 Google MapReduce Google MapReduce é uma implementação proprietária da Google, projetado em C++ podendo executar aplicações escritos em várias linguagens de programação. Essa implementação do MapReduce é direcionada para o ambiente de computação da Google feito por grandes aglomerados de PCs. O GFS (Google File System) é um sistema de arquivos distribuído desenvolvido pela Google, é usado para gerenciar os dados armazenados sobre os discos rígidos do grid computacional. O sistema de arquivos usa replicação para fornecer disponibilidade e confiabilidade em cima de hardware não confiável. O programador envia trabalhos para um sistema de agendamento e cada tarefa do trabalho é mapeado pelo agendador para um conjunto de máquinas disponíveis dentro de um cluster (DEAN & GHEMAWAT, 2008, p. 2).
  23. 23. 22 2.4.2 Apache Hadoop Apache Hadoop é uma implementação de código aberto do MapReduce implementado em Java, que permite o processamento distribuído e o armazenamento de grandes conjuntos de dados em clusters de computadores de máquinas comuns. Ele fornece um sistema de arquivos distribuído (HDFS) que armazena dados sobre os nós do cluster, proporcionando elevada largura de banda agregada em todo o cluster. Hadoop MapReduce pode executar aplicações implementada em várias linguagem, podendo ser escrita em Java , Ruby , Python e C++. As tecnologias MapReduce e Hadoop Distributed File System são projetadas para detectar e lidar com falhas na camada de aplicação, entregando um serviço altamente disponível em ambiente propenso a falhas. Outros projetos de código aberto para uma proposta específica foram construídos com Hadoop, na qual foram incorporados ao seu ecossistema, tornando uma infraestrutura cada vez mais completa (HADOOP, 2014). A aplicação Hadoop em um aglomerado de máquinas utiliza cinco componentes diferentes, o NameNode, o DataNode, o SecondaryNameNode, o JobTracker e o TaskTracker. O NameNode gerencia os arquivos de metadados armazenados no HDFS, como a estrutura de diretório de arquivos e a localização das cópias dos blocos de dados. O DataNode é o responsável pelo armazenamento dos dados no HDFS. O SecondaryNameNode fornece backup e compactação de metadados do sistema de arquivos. O JobTracker fornece comando e controle para o gerenciamento do trabalho, lidando com a distribuição e gerenciamento das tarefas. O TaskTracker fornece serviços de execução para as tarefas MapReduce, gerenciando a execução no cluster e executando as tarefas Map e as tarefas Reduce. 2.4.3 Twister Twister é uma implementação em Java de código aberto e uma extensão do MapReduce otimizado para computação iterativa. O Twister usa uma infraestrutura
  24. 24. 23 de mensagens, publicação/assinatura, para a comunicação e transferência de dados e suporta longa duração de tarefas map e reduce. Além disso, fornece uma extensão de programação para o MapReduce, permitindo o Twister suportar computação MapReduce iterativa, isso é feito através do adicionamento de uma nova fase para o MapReduce chamado "Combine", que atua como um outro nível de redução, pode ser usada para produzir uma saída coletiva a partir de todas as saídas da fase reduce (EKANAYAKE et al., 2010, p. 1). 2.4.4 Phoenix O Phoenix é uma versão do MapReduce implementada em C e de código aberto, direcionado para sistemas multicore e multiprocessadores simétricos de memória compartilhada. Em contraste com o sistema MapReduce original que foi projetado para clusters, o Phoenix usa threads de memória compartilhada para implementar o paralelismo. A implementação lança vários threads de trabalho para executar as funções map e reduce do usuário (YOO et al., 2009, p. 2). Phoenix consiste em uma API (bibliotecas) para a programação de aplicativo e um framework que lida com a paralelização, gerenciamento de recursos e de recuperação de falhas. A implementação do Phoenix fornece uma API para C e C++. (RANGER et al., 2007, p. 3). 2.4.5 Mars Mars é uma implementação MapReduce para processadores gráficos (GPUs). Mars explora grande quantidades threads paralelo dentro da GPU, esconde a complexidade de programação da GPU por trás da interface MapReduce. Mars fornece um pequeno conjunto de APIs, implementadas em C/C++, para os desenvolvedores que não requer nenhum conhecimento de renderização gráfica (HE et al., 2008, p. 4-5).
  25. 25. 24 2.4.6 CELL MapReduce Cell MapReduce é uma implementação do modelo MapReduce escrito em C para processador Cell. Este modelo fornece uma abstração para máquina simples, escondendo a paralelização e o hardware. A arquitetura Cell é uma arquitetura de memória distribuída, é um projeto de alto nível que se assemelha ao projeto do Google, enquanto a granularidade das operações é semelhante ao Phoenix. O modelo de programação é adequado a vários programas de dados paralelos, mapeando naturalmente para a arquitetura Cell (KRUIJF & SANKARALINGAM, 2007). 2.4.7 MRPGA Uma extensão para o MapReduce para paralelização automática de Algoritmos Genéticos com a programação sequencial através de três componentes: Map, Reduce, e Reduce, chamado MRPGA (MapReduce for Parallel Genetic Algorithms). A aplicação do usuário pode ser implementado em C++, C# e Visual Basic, ou com qualquer linguagem suportada pela plataforma “.NET” (JIN et al., 2008, p. 1-6). 2.5 CONCLUSÃO MapReduce é um modelo de programação para o processamento de grandes conjuntos de dados em ambiente computacional paralelo e distribuído. O paradigma é poderoso, mas simples o suficiente para o desenvolvimento das aplicações BigData. Além disso, existe uma variedade de implementação, algumas de código fonte aberto para diversos ambientes e propósitos. Para testar o modelo de programação MapReduce apresentaremos no próximo capítulo a implementação MapReduce de código aberto Apache Hadoop, demonstrando suas características, estrutura e funcionamento.
  26. 26. 25 3 HADOOP O Apache Hadoop, ou simplesmente Hadoop, é uma ferramenta para processamento de grande quantidade de dados em aglomerados computacionais, disponibilizando recursos para o desenvolvimento de soluções em sistemas paralelo e distribuídos em um único arcabouço. Este capítulo descreve o Apache Hadoop, suas características, estrutura e funcionamento. Na seção 3.1 é apresentando uma visão geral da ferramenta. Na seção 3.2 é demonstrado o sistema de arquivos distribuído HDFS. Na seção 3.3, demonstra-se o framework Hadoop MapReduce, suas características e execução, finalizando com uma conclusão na seção 3.4. 3.1 INTRODUÇÃO Hadoop é um implementação MapReduce de código aberto, escrito em Java para o processamento e armazenamento em larga escala, utilizando máquinas comuns, sendo seus principais componentes o Framework MapReduce e o Hadoop Distributed File System (HDFS). Hadoop permite o processamento distribuído e o armazenamento de grandes conjuntos de dados em clusters de computadores, fornecendo um sistema de arquivos distribuído que armazena dados sobre os nós de computação, proporcionando elevada largura de banda agregada em todo o cluster. O Framework MapReduce e Hadoop Distributed File System (HDFS) são projetados para detectar e lidar com falhas na camada de aplicação, entregando um serviço altamente disponível em ambiente propenso a falhas (HADOOP, 2014). 3.1.1 Componentes A aplicação Hadoop em um aglomerado utiliza cinco componentes (daemons) diferentes. Três deles, o NameNode, o DataNode e o SecondaryNameNode, compõem o sistema de arquivos HDFS; os outros dois componentes, o JobTracker e o TaskTracker, integram o framework MapReduce.
  27. 27. 26 O NameNode gerencia os arquivos de metadados armazenados no HDFS incluindo informações críticas, como a estrutura de diretório de arquivos e a localização das cópias dos blocos de dados do arquivo. A máquina que executa o processo do servidor NameNode é o mestre HDFS (VENNER, 2009, p. 73). O DataNode realiza o armazenamento dos dados no HDFS. Como o HDFS é um sistema de arquivos distribuído, necessita diversas instâncias do DataNode. Cada DataNode fornece serviços de armazenamento em blocos para o HDFS (VENNER, 2009, p. 73). O SecondaryNameNode fornece backup e compactação de metadados do sistema de arquivos fornecendo backup quase em tempo real dos metadados para o NameNode. Há pelo menos um caso deste servidor executando em um cluster. O NameNode secundário também mescla o histórico de alterações de metadados, o log de edição, na imagem do sistema de arquivos do NameNode (VENNER, 2009, p. 73). O JobTracker fornece comando e controle para o gerenciamento do trabalho. Ele também lida com a distribuição e gerenciamento de tarefas. Há uma instância desse servidor executando em um cluster. A máquina que executa o servidor JobTracker é o mestre MapReduce (VENNER, 2009, p. 72). O TaskTracker fornece serviços de execução para a tarefa MapReduce. Cada TaskTracker gerencia a execução de tarefas em um nó do cluster. Um TaskTracker executa uma tarefa Map ou uma tarefa Reduce designada a ele. Há uma instância do TaskTracker por nó escravo no cluster (VENNER, 2009, p. 72). 3.1.2 Modo de Execução Há três modos de execução: Modo Local, Modo Pseudo Distribuído e Modo Completamente Distribuído. Modo Local (Standalone Mode) é a configuração padrão de execução do Hadoop. Não existem daemons sendo executados e tudo é executado em uma única Máquina Virtual Java (JVM). Nessa configuração, todo o processamento da
  28. 28. 27 aplicação é executado apenas na máquina local, não sendo necessário usar o HDFS para armazenar os arquivos. Esse modo é adequado para a execução de programas MapReduce durante o desenvolvimento, uma vez que é mais fácil de testar e depurar. Modo Pseudo Distribuído (Pseudo Distributed Mode) é o modo no qual são aplicadas todas as configurações necessárias para execução em um aglomerado, porém os daemons do Hadoop são executados na máquina local, simulando assim um aglomerado de pequena escala. Modo Completamente Distribuído (Fully Distributed Mode) é o modo no qual os daemons do Hadoop rodam em um cluster de máquinas. Este modo é utilizado para o processamento distribuído da aplicação Hadoop em um aglomerado real. 3.2 HDFS Quando um conjunto de dados supera a capacidade de armazenamento de uma única máquina física, torna-se necessário particioná-lo através de um número de máquinas separadas. Sistemas de arquivos que gerenciam o armazenamento através de uma rede de máquinas são chamados de sistemas de arquivos distribuído (WHITE, 2010, p. 41). O HDFS é um sistema de arquivos distribuído projetado para armazenar de forma confiável grandes conjuntos de dados e para proporcionar alta tolerância a falhas, funciona em grandes aglomerados de máquinas comuns, destinado ao armazenamento e transmissão de arquivos de centenas de Megabytes a Terabytes de dados. O HDFS fornece acesso de alta taxa de transferência de dados adequado para aplicações que têm grandes conjuntos de dados (WHITE, 2010, p. 41-42). HDFS utiliza o conceito de bloco, cujo tamanho padrão é de 64 MB. Como em um sistema de arquivos tradicionais, os arquivos no HDFS são quebrados em pedaços de blocos, que são armazenados como unidades independentes. Entretanto, quando um arquivo for menor do que um único bloco, o espaço restante do bloco poderá ser utilizado. O beneficio que o bloco de abstração traz para um sistema de arquivos distribuído é que um arquivo pode ser maior do que qualquer
  29. 29. 28 disco único na rede. Além disso, os blocos se encaixam bem com a replicação para fornecer tolerância a falhas e disponibilidade. Para evitar problemas com os blocos corrompidos e disco e falha da máquina, cada bloco é replicado para um pequeno número de máquinas fisicamente separado (WHITE, 2010, p. 43-44). Um cluster HDFS tem dois tipos de nó que operam em um padrão de mestre/escravo. Possui um nó mestre chamado NameNode, e uma série de escravos chamados DataNodes. O NameNode gerencia o espaço de nomes do sistema de arquivos, mantém as informação da árvore de arquivos e dos metadados no disco local. O NameNode também conhece os DataNodes onde todos os blocos dos arquivos estão localizados. DataNode armazenam e recuperam blocos quando é solicitado e apresentam um relatório ao NameNode periodicamente com listas de blocos que estão sendo armazenado (WHITE, 2010, p. 44). Sem o NameNode, o sistema de arquivos não pode ser usado, pois os arquivos seriam irrecuperáveis. Por esse motivo, o Hadoop proporciona dois mecanismos para fazer a NameNode resistente a falhas, através do backup ou SecondaryNameNode . O primeiro mecanismo é fazer backup dos arquivos que compõem o estado persistente de metadados do sistema de arquivos. Hadoop pode ser configurado para que o NameNode grave seu estado de persistente para múltiplos sistemas de arquivos. O segundo mecanismo é por execução de um NameNode secundário chamado de SecondaryNameNode, que age diferente do NameNode. O seu principal papel é mesclar periodicamente a imagem namespace com o log de edição. Ele mantém uma cópia da imagem namespace mesclado, que pode ser usado em caso de falha do NameNode (WHITE, 2010, p. 44-45). 3.3 FRAMEWORK MAPREDUCE Um dos principais componente do Hadoop é um framework para processamento paralelo e distribuído de grandes conjuntos de dados para grandes aglomerados computacionais. Permite a execução de tarefa simples, escondendo os
  30. 30. 29 detalhes da paralelização, tolerância a falhas, distribuição de dados e balanceamento. 3.3.1 Execução do Trabalho Há quatro entidades independentes na execução do trabalho MapReduce: o cliente, que envia o trabalho de MapReduce; o JobTracker, que coordena a execução do trabalho; os TaskTrackers, que executam as tarefas do trabalho que foi dividido; e, o sistema de arquivos distribuídos HDFS, que é usado para o compartilhamento de arquivos de trabalho entre as outras entidades (WHITE, 2010, p. 167). O processo de execução do trabalho MapReduce no Hadoop é feito através das seguintes etapas: processo de envio do trabalho, inicialização, atribuição e execução de tarefa e a conclusão do trabalho MapReduce. Esses passos são explicados a seguir. Envio de Trabalhos: O processo de submissão solicita ao JobTracker um novo ID de trabalho, em seguida verifica a especificação de saída do trabalho e calcula as divisões de entrada para o trabalho. Os recursos necessários para execução do trabalho são copiados, incluindo o arquivo JAR do trabalho, o arquivo de configuração, e as divisões de entrada, para o sistema de arquivos do JobTracker. E no final indica ao JobTracker que o trabalho está pronto para execução (WHITE, 2010, p. 167-169). Inicialização do Trabalho: Quando o JobTracker recebe uma chamada de submissão de trabalho, ele coloca o trabalho em uma fila interna onde o agendador de tarefas vai buscá-lo e inicializá-lo. A inicialização envolve a criação de um objeto para representar o trabalho que está sendo executado, que encapsula as tarefas e informações para o acompanhamento do seu status e progresso. Para criar a lista de tarefas a serem executadas, o agendador de tarefas recupera primeiro as divisões de entrada do sistema de arquivos compartilhado. Em seguida, cria uma tarefa map para cada divisão de entrada, e o número de tarefas reduce é definido pelo agendador (WHITE, 2010, p. 169).
  31. 31. 30 Atribuição de tarefas: Tasktrackers executam um loop simples que envia periodicamente chamadas Heartbeats1 para o JobTracker. O Heartbeats funcionam como um canal de mensagens que dizer ao JobTracker que uma TaskTracker está ativo. Como parte dos Heartbeats, o TaskTracker vai indicar se ele está pronto para executar uma nova tarefa. Tasktrackers tem um número fixo de slots2 para as tarefas map e para tarefas reduce, podendo executar tarefas map e reduce simultaneamente. O agendador padrão preenche os slots vazios com as tarefas map antes das tarefas reduce (WHITE, 2010, p. 169). Execução de Tarefas: Após a atribuição da tarefa no TaskTracker, o próximo passo é a execução da tarefa. Para isso ele deve localizar a aplicação "JAR", copiando do sistema de arquivos compartilhado para o sistema de arquivos do TaskTracker. Em seguida, ele deve criar um diretório de trabalho local para a tarefa, e criar uma instância de TaskRunner para execução dela. TaskRunner lança uma nova JVM para executar cada tarefa, de modo que todos os erros da aplicação map e reduce do usuário não afetem o TaskTracker (WHITE, 2010, p. 170). Conclusão do trabalho: Quando o JobTracker recebe uma notificação de que a última tarefa para um trabalho é concluído, ele muda o status do trabalho para "sucesso". Se o trabalho foi concluído com êxito, o usuário é informado e posteriormente o JobTracker limpa o estado de funcionamento do trabalho e instrui TaskTrackers a fazer o mesmo (WHITE, 2010, p. 172-173). 3.3.2 Partitioners e Combiners Existem dois elementos adicionais que completam o modelo de programação: Partitioners (particionadores) e Combiners (combinadores). Partitioners são responsáveis por dividir as chaves intermediárias e atribuir os pares chave/valor intermediário para as tarefas reduce, ou seja, especifica para onde o par chave/valor intermediário deve ser copiado. Dentro de cada tarefa reduce, as chaves são processadas em ordem de classificação. O Particionador 1 São “sinais de vida” para verificar se o componente hadoop está “vivo”. 2 São espaços para armazenamento e execução das tarefas.
  32. 32. 31 mais simples envolve calcular o valor Hash da chave e, em seguida, tomar o resto da divisão (mod) desse valor com o número de tarefas reduce, ou seja, hash(key) mod R. Isso atribui aproximadamente o mesmo número de chaves para tarefas reduce (LIN & DYER, 2010, p. 28-29). Combiners são uma otimização no MapReduce que permite a agregação local. O combinadores é como se fosse um “mini-reducers” que ocorrem na saída da fase Map, antes da fase shuffle e sort (especificado em seguida) podendo reduzir o número de pares de chave/valore intermediários, tonando mais eficiente, pois os pares de chave/valor precisam ser copiados em toda a rede, tornado a troca de dados mais rápido. Cada combinador opera isoladamente e, portanto, não tem acesso a saída intermediária de outras funções map. O combinador recebe os pares chave/valore associados a cada chave. O combinador pode emitir qualquer número de pares chave/valor, mas o seu tipo deve ser o mesmo da saída da fase Map, pois se o combinador não ocorrer, a saída da função map será a entrada da função reduce (LIN & DYER, 2010, p. 29). 3.3.3 Shuffle e Sort MapReduce garante que a entrada para cada reduce é classificada por chave. O processo pelo qual o sistema executa a classificação (Sort), e transfere das saídas do map para a entrada do reduce, é conhecido como o Shuffle. De certa maneira, o shuffle é o coração do MapReduce (WHITE, 2010, p. 177). Na fase Map quando a função map começa a produzir a saída, não é simplesmente gravado no disco. O processo é mais complexo, é tira proveito de buffer, escrevendo na memória e fazer algumas pré-classificação por razões de eficiência como pode se visto na Figura 3.1. Cada tarefa map tem um buffer de memória circular na qual é escrito sua saída. O buffer é de 100 MB por padrão, um tamanho que pode ser alterado. Quando o conteúdo da memória intermediária atinge um determinado tamanho começará a transferência (spill) do conteúdo para o disco. A saída map continuará sendo escrito no buffer, enquanto o spill acontece, mas se o buffer enche durante este tempo, o map irá bloquear até que o spill estiver completo (WHITE, 2010, p. 177).
  33. 33. 32 Figura 3.1. Shuffle e Sort em MapReduce (WHITE, 2010, p.178). Antes de gravar no disco, ocorre uma divisão dos dados em partições (partition) correspondentes aos reduce. Em cada partição é executada uma classificação (sort) por chave na memória, e se existe uma função Combiner, esta é executada usando saída da classificação. Para cada spill um novo arquivo é criado, então no fim da tarefa map pode haver vários arquivos Spill. Antes que a tarefa seja concluída, os arquivos Spill são mesclados (merge) em um único arquivo de saída dividido e classificado. Se a função combinadora for especificada, o número de spill será menor, reduzindo assim o espaço em disco, e a quantidade de dados a ser transferida para o reduce (WHITE, 2010, p. 178). Na fase Reduce, o arquivo de saída map é armazenado no disco local do TaskTracker que executou a tarefa map, mas agora é necessário pelo TaskTracker que executará as tarefas de reduce. Além disso, a tarefa reduce precisa das partiçãos específicas das saídas map de todas as tarefas map do cluster. As tarefas map podem terminar em momentos diferentes, por isso a tarefa reduce começará a copiar os seus resultados, assim que cada um é concluído. Isto é conhecido como a fase de cópia da tarefa reduce (WHITE, 2010, p. 179). As saídas de map são copiados para a memória do TaskTracker Reduce, se forem pequenas o suficiente, se não, são copiados para o disco. Quando o buffer de memória atinge um tamanho limite, ou atinge um limite do número de saídas de
  34. 34. 33 map, os dados são fundidos e transferidos (Spill) para o disco. Como as cópias são acumuladas no disco, é feito antecipadamente a fusão (merge) em um grande arquivo ordenado (WHITE, 2010, p. 179). Quando todas as saídas map forem copiadas, a tarefa reduce passa para a fase de classificação, que funde as saídas map, mantendo a sua ordem de classificação. A fusão salva em um caminho para o disco, alimentando diretamente a função reduce, que é a última fase, a fase reduce. Durante a fase de redução, a função reduce é chamada para cada chave da saída classificada. A saída resultante dessa fase é escrito diretamente no sistema de arquivos de saída, geralmente o HDFS. Neste caso o nó do TaskTracker também executará um DataNode (WHITE, 2010, p. 179-180). 3.3.4 Aplicações A aplicação MapReduce do Hadoop usa uma biblioteca do MapReduce (API) que está no pacote org.apache.hadoop.mapreduce e outras do pacote org.apache.hadoop, como o subpacote io e fs.Path além das API do próprio Java. A aplicação deve ter as classes que representam as funções map e reduce, uma classe principal (Drive) e as classes auxiliares da lógica de execução. Ao invés de usar tipos Java, Hadoop fornece seu próprio conjunto de tipos básicos que são otimizados para serialização de rede. Estes se encontram no pacote org.apache.hadoop.io. Hadoop usa seu próprio formato de serialização de dados, através da interface Writables. Essa interface define dois métodos, o write() para escrever o seu estado no fluxo binário pelo DataOutput, e o readFields() para a leitura de seu estado no fluxo binário pelo DataInput. Qualquer chave ou valor do framework MapReduce Hadoop implementa essa interface. Hadoop vem com uma grande variedade de classes de Writable, na qual possui implementação para quase todos os tipos primitivos do Java, conforme a Tabela 3.1.
  35. 35. 34 Tabela 3.1: Representação do tipo primitivo Java em implementação do Writable. Tipo Primitivo do Java Implementação Writable boolean BooleanWritable byte ByteWritable int IntWritable long LongWritable float FloatWritable double DoubleWritable Além do que estão na Tabela 3.1 há várias outras implementações, como os tipos: Text, um Writable para sequencias UTF-8; NullWritable, um tipo que tem uma serialização de comprimento zero; ObjectWritable, para propósito geral. É possível escrever uma implementação personalizada tendo o controle sobre a representação binária e a ordem de classificação (WHITE, 2010, p. 96-97). A função map é representada por uma classe derivada da classe abstrata Mapper, que é encontrada no pacote org.apache.hadoop.mapreduce. A classe abstrata Mapper é um tipo genérico, que lhe permite trabalhar com qualquer tipo de chave ou valor, os quatro parâmetros especificam a chave de entrada, valor de entrada, a chave de saída e valor de saída (WHITE, 2010, p. 20-21). Essa classe declara quatro métodos, o setup, o map, o cleanup e o run, que pode ser usada pela aplicação do usuário. O framework primeiro chama o método setup() que é executado uma vez no início da tarefa, em seguida é chamado o método map() para cada par chave/valor da divisão de entrada. Finalizando com a chamada do método cleanup() que é executado uma vez no fim da tarefa. O método run() é utilizado para ter um controle mais completo sobre a execução do Mapper. A função reduce é representada por uma classe derivada da classe abstrata Reducer, um tipo genérico semelhante ao Mapper que se encontram no mesmo pacote. O Reducer tem quatro parâmetros que são usados para especificar o tipo de entrada e saída da função reduce. Os tipos de entrada da função reduce devem coincidir com os tipos de saída da função de map. A classe Reducer tem quatro métodos, o setup, o reduce, o cleanup e o run, três são semelhantes ao do Mapper.
  36. 36. 35 O framework executa os métodos da mesma forma que é executado na tarefa map, porém o método reduce() é chamado uma vez para cada chave. Os parâmetros de configuração do trabalho são efetuados na classe principal (Drive), onde são definidos os caminhos de entrada e saída dos arquivos, as classes Mapper, Reducer, Combiner e Partitioner, os tipos de saída e entrada, além disso, é efetuado o controle, a execução e monitoramento do trabalho. 3.4 CONCLUSÃO Hadoop é uma implementação MapReduce de código aberto, utilizado para o processamento e armazenamento em larga escala, utilizando máquinas comuns, e traz simplicidade para o desenvolvimento e execução de aplicação paralelo e distribuídos. Os principais componente são o Hadoop Distributed File System o Framework MapReduce que dão suporte a execução da aplicação MapReduce. No capítulo seguinte apresentaremos a base teórica do Algoritmo Genético (AG) e do Problema do Caixeiro Viajante (PCV) para a modelagem de uma aplicação MapReduce.
  37. 37. 36 4 AG & PCV O Algoritmo Genético (AG) é uma técnica de otimização utilizada como busca global, empregada em situações nas quais o número de valores ou combinações aplicáveis para resolver um determinado problema é muito alto (BRYANT, 2000; MISHRA, 2011; PACHECO, 1999). Este é o caso do Problema do Caixeiro Viajante (PCV), em que o número de combinações de caminhos aumenta exponencialmente em função do número de cidades. O PCV é um problema de otimização que consiste em encontrar o menor caminho em um conjunto de cidades, sendo utilizada em pesquisas e aplicações de diferentes áreas, como da matemática, da engenharia e ciência da computação. Para essa classe de problema não existe recurso computacional para resolvê-lo em tempo hábil, tornando a utilização de método de força bruta difícil, necessitando o uso de técnica de busca, como o caso dos Algoritmos Genéticos que não necessita explorar todas as soluções possíveis para encontrar uma boa solução. Este capítulo apresenta a técnica do Algoritmo Genético e o Problema do Caixeiro Viajante, apresentando uma visão geral e seus conceitos. Na seção 4.1 é definida a técnica do Algoritmo Genético e as características dos Operadores Genéticos. Na seção 4.2 é apresentado o Problema do Caixeiro Viajante seus conceitos e métodos AG particulares. Finalizando, na seção 4.3 com as considerações do capítulo. 4.1 ALGORITMOS GENÉTICOS Algoritmos Genéticos (AG) são técnicas de otimização baseadas na evolução natural. Essas técnicas incluem a ideia da sobrevivência do mais apto em um algoritmo de pesquisa, que não necessita explorar todas as soluções possíveis no espaço de busca para obter um bom resultado (BRYANT, 2000, p. 2). O AG usa um processo evolutivo para criar uma população de possíveis respostas para um problema, em seguida, combina as melhores soluções criando uma nova geração de soluções que devem ser melhor do que a geração anterior.
  38. 38. 37 Este processo é constituído pelas seguintes etapas: a) Inicialização: é a criação da população inicial para o primeiro ciclo do algoritmo; a criação é geralmente realizada de forma aleatória. b) Avaliação: avalia-se a aptidão das soluções analisando sua resposta ao problema proposto. c) Seleção: indivíduos são selecionados para a reprodução; a seleção é baseada na aptidão dos indivíduos. d) Cruzamento: características das soluções escolhidas são recombinadas, gerando novos indivíduos. e) Mutação: características dos indivíduos resultantes do processo de reprodução são alteradas. f) Atualização: os indivíduos criados nesta geração são inseridos na população. g) Finalização: verifica se as condições de encerramento da evolução foram atingidas. Inicialmente deve ser definido o conceito para "indivíduo", encontrando a melhor codificação adequada para a solução do problema. A população inicial é então selecionada, geralmente de forma aleatória, calculando-se a aptidão de cada indivíduo. Esta aptidão é usada para encontrar os indivíduos para cruzamento, e recombinados para criar novos indivíduos que são copiados para a nova geração. Alguns indivíduos são escolhidos ao acaso para sofrer mutação. Após esse processo, uma nova geração é formada e o processo é repetido até que algum critério de parada tenha sido atingido. Neste ponto, o indivíduo que está mais próximo do ideal é decodificado e o processo é concluído (BRYANT, 2000, p. 2-3). 4.1.1 Indivíduos e a População Os indivíduos codificam possíveis soluções do espaço de busca de um problema. A representação dessas soluções define a estrutura do cromossomo3 a 3 Segundo Pacheco (1999) o cromossomo é uma estrutura de dados que representa uma das possíveis soluções do espaço de busca do problema.
  39. 39. 38 ser manipulado, e depende do tipo de problema e do que se deseja manipular pelo algoritmo genético. O AG usa nomenclatura relacionada com os termos que podemos encontrar na biologia. O indivíduo do AG, de acordo com a Figura 4.1, é composto de um ou mais cromossomo e um valor adaptativo associado (fitness). O cromossomo é uma cadeia de caracteres codificada de parâmetros. Normalmente, um indivíduo contém apenas um cromossomo, que representa o conjunto de parâmetros chamados de genes. O gene (ou caractere) é a versão codificada de um parâmetro do problema a ser resolvido. O alelo é o valor que um gene pode assumir e o lócus é a posição que gene ocupa no cromossomo (ALBA, 1999, p. 3). Figura 4.1. Detalhe do indivíduo AG (ALBA, 1999, p. 4). A população é um conjunto de indivíduos candidatos à solução do problema, ela é uma parte do espaço de busca de um problema. O tamanho da população irá depender do problema (HUANG & LIN, 2010, p. 5). A população possui como características o número de geração, o grau de convergência, a diversidade e o elitismo. O número de geração é quantas vezes a população passa pelo processo de seleção, reprodução, mutação e atualização. O grau de convergência representa a aproximação da média de adaptação da geração atual em relação a anteriores. A diversidade mede o grau de variação entre os indivíduos presentes na população; ela é fundamental para a amplitude da busca. O baixo valor da diversidade está vinculado ao fenômeno de convergência prematura, isto é, quando a população converge e não consegue sair de uma média de adaptação sub-ótima (ótima local). O elitismo é composto pelos indivíduos mais adaptados da população, onde são sempre mantidos a cada geração (LUCAS, 2002, p. 9).
  40. 40. 39 4.1.2 Inicialização A inicialização da população de um AG determina o processo de criação dos indivíduos para o primeiro ciclo do algoritmo. Geralmente, a população inicial é formada a partir de um conjunto de indivíduos aleatoriamente criados, com o objetivo de fornecer maior diversidade, para garantir uma boa abrangência do espaço de busca. Existem várias alternativas ao método randômico, destinadas a suprir deficiências na criação aleatória de indivíduos de representação mais complexa, algumas técnicas são: Inicialização Randômica Uniforme, em que cada gene do indivíduo é um valor do conjunto de alelos, sorteado de forma aleatoriamente uniforme; Inicialização Randômica não Uniforme, em que os valores do gene tendem a ser escolhidos com uma frequência maior do que o restante; e na Inicialização Randômica Com “Dope”, no qual os indivíduos otimizados são inseridos em meio à população aleatoriamente gerada (LUCAS, 2002, p. 10-11). 4.1.3 Processo de Avaliação e Seleção A avaliação é feita através de uma função que representa o problema, fornecendo uma medida de aptidão para cada indivíduo na população. A função de aptidão indica a qualidade de um indivíduo para solução do problema. Em muitos casos, calcular o grau de adaptação dos indivíduos pode ser uma tarefa complexa, e se levarmos em conta que esta operação é massivamente repetida ao longo do processo de evolução, seu custo pode ser consideravelmente alto (LUCAS, 2002, p. 12). No algoritmo genético, o processo de seleção escolhe os melhores indivíduos para o cruzamento, baseada na aptidão dos indivíduos, efetuando-se um sorteio, onde os mais aptos possuem maior probabilidade de serem escolhidos para a reprodução, perpetuando-o para a próxima geração, mantendo as boas características da espécie.
  41. 41. 40 A seleção opera de forma determinística, isto é, um indivíduo só consegue sobreviver em um ambiente se for capaz de se reproduzir, de acordo com suas características, de responder de forma adequada a todos os fenômenos de seu meio. A seleção também é cumulativa, pois os benefícios do processo de seleção são mantidos de uma geração para a outra (LUCAS, 2002, p. 12). Existem vários métodos para efetuar a seleção, dentre os quais se destacam: a seleção por Ranking, onde os indivíduos da população são ordenados de acordo com seu valor de aptidão, sendo os melhores ranqueados (os mais aptos) os escolhidos para a próxima geração. A seleção por Giro de Roleta, onde é atribuída uma probabilidade para cada indivíduo em função do seu valor de aptidão; os que possuem as maiores possibilidades são os escolhidos a passar para a próxima geração. Seleção por Torneio, em que grupos de soluções são escolhidos aleatoriamente e os indivíduos mais aptos dentro de cada grupo são selecionados para ficar para a próxima geração. E a seleção Uniforme, em que todos os indivíduos possuem a mesma probabilidade de serem selecionados. 4.1.4 Processo de Cruzamento e Mutação O cruzamento (crossover) é um mecanismo de recombinação de soluções. É o processo fundamental dos AG, que possibilita a troca e manipulação de material genético entre indivíduos trazendo melhoria para sua população. O cruzamento consiste na escolha de dois indivíduos, resultante do processo de seleção, que são combinados para permitir a criação de um ou mais indivíduos filhos. Há vários métodos de escolha de pares para o cruzamento, que pode ser por escolha aleatória, escolha entre indivíduos semelhantes ou entre indivíduos diferentes. A mutação é realizada após o cruzamento. Baseado em uma probabilidade predeterminada, é feita uma escolha aleatória de um indivíduo, em seguida, é escolhido aleatoriamente um ponto ou uma parte do cromossomo do indivíduo para fazer mutação. A mutação é um operador exploratório, responsável por provocar pequenas alterações genéticas nos indivíduos, permitindo ampliar o espaço de busca do
  42. 42. 41 problema, na tentativa de chegar a soluções possíveis na qual o operador de cruzamento não encontraria. As principais funções da mutação é a inserção de novas características e a reposição de material genético perdido nos outros processos, aumentando assim a diversidade na população. 4.1.5 Processo de Atualização e Finalização Os indivíduos resultantes do processo de cruzamento e mutação são inseridos na população de acordo com a técnica de atualização adotada pelo AG, gerando assim uma nova população. Essa técnica determina o critério de substituição dos indivíduos de uma população para a próxima geração. Segundo Pacheco (1999), a atualização pode ser feita pela troca de todos os indivíduos da população anterior pelos novos indivíduos gerados, ou ainda, a troca de toda a população com elitismo, ou seja, o indivíduo mais apto da população anterior é mantido na nova população. Outra técnica elitista é a troca parcial da população em que são gerados novos indivíduos para substitui os piores indivíduos da população anterior, permitindo ou não a presença de indivíduos duplicados. O último passo é realizado por um teste que observa se algum critério de parada foi satisfeito, finalizando o processo de evolução. Nos AGs, o critério de parada pode ser: pelo número de gerações que corresponde ao total de ciclos de evolução de um AG; pelo total de indivíduos, que é o total de tentativas em um experimento, ou seja, o produto do tamanho da população pelo número de gerações; e pelo grau de convergência da população, ou seja, o grau de proximidade dos valores da avaliação de cada indivíduo da população. 4.2 PROBLEMA DO CAIXEIRO VIAJANTE O Problema do Caixeiro Viajante (PCV), no inglês Traveling Salesman Problem (TSP), é um problema de otimização NP-difícil mais estudada. Sua popularidade se deve ao fato que PCV é fácil de formular, apesar de difícil solução, tem um grande número de aplicações, tais como problema de roteamento de
  43. 43. 42 veículos, a reformulação de motores de turbinas em aeronaves e otimização das tarefas de máquinas industriais (GUTIN, 2009, p. 1). O PCV consiste em encontrar o menor caminho para um caixeiro viajante que, dado um conjunto de cidades, deve visitar todas elas precisamente uma vez, com exceção à cidade de origem na qual deve ser feito o retorno. Tem duas versões do PCV, o simétrico e o assimétrico. O PCV Simétrico (PCVS) é um grafo completo não direcionado com pesos nas arestas, como pode ser visto na Figura 4.2. O PCV Assimétrico (PCVA) é um grafo direcionado completo, também com pesos sobre suas arestas, cujo objetivo é encontrar um ciclo Hamiltoniano de peso mínimo, ou seja, que a soma dos pesos das arestas do ciclo seja o menor possível. Um ciclo Hamiltoniano em um grafo e é frequentemente chamado de tour (turnê ou caminho). Figura 4.2: Grafo completo no plano Euclidiano. O PCVA tem o número de caminhos possíveis dada pela fórmula , onde n é o número de cidades e o PCVS tem o número de caminhos igual a , pois a direção do caminho não importa (GUTIN, 2009, p. 1). Nos dois casos o número de caminhos possíveis para n cidades é muito grande, quase exponencial como se pode ver na Tabela 4.1. A utilização do método de força bruta, que examina todos os passeios possíveis, torna-se impraticável mesmo para instâncias de problemas de tamanho moderado.
  44. 44. 43 Tabela 4.1: Números possíveis de caminho em função do número de cidades no problema do caixeiro viajante simétrico (PCVS). Número de cidades Número de caminhos Escala Número de cidades Número de caminhos Escala 3 1 13 239.500.800 4 3 14 3.113.510.400 Bilhões 5 12 15 43.589.145.600 6 60 16 653.837.184.000 7 360 17 10.461.394.944.000 Trilhões 8 2.520 Mil 18 177.843.714.048.000 9 20.160 19 3.201.186.852.864.000 Quatrilhões 10 181.440 20 60.822.550.204.416.000 11 1.814.400 Milhões 21 1.216.451.004.088.320.000 Quintilhões 12 19.958.400 22 25.545.471.085.854.720.000 O PCV Euclidiana é um caso especial de PCVS em que os vértices são pontos no plano euclidiano e o peso em cada aresta é a distância euclidiana entre os seus terminais, conforme é visto na Figura 4.2. Se os vértices de um grafo representar um conjunto de cidades e a distância euclidiana for calculada em um sistema de coordenadas cartesianas, então a distância entre duas cidades i e j é dada pela equação (4.1), onde cada cidade é representada por uma coordenada (x, y). Para resolver o PCV é necessário conhecer as distâncias entre todas as cidades. Os métodos de resolução podem ser divididos em duas grandes classes: Algoritmos Exatos e Heurísticas PCV ou Algoritmos de Aproximação PCV. Algoritmos Exatos são métodos para resolver o problema PCV, ou seus casos especiais para otimização, quando queremos obter um passeio ideal. Isto não pode ser possível, se o algoritmo exigir tempo de execução de várias horas ou dias.
  45. 45. 44 Heurísticas PCV ou Algoritmos de Aproximação PCV é aplicado se houver alguma garantia de aproximação, aplicado quando o tempo de execução for limitado ou os dados não são exatos (GUTIN, 2009, p. 4). O AG é uma técnica de otimização que pode ser empregada no caso do PCV. Para isso, é necessário definir a representação da solução, a função que avalia a aptidão das soluções gerada pelo algoritmo e os operadores genéticos para gerar novas soluções, preservando as condições inerentes do problema. Tais questões são detalhadas a seguir. 4.2.1 Codificação No problema do caixeiro viajante a solução (indivíduo) é codificada em uma lista sequenciada de n cidades a serem visitadas. As cidades (gene) são representadas pelos caracteres de um alfabeto válido. Esta lista de cidades é o cromossomo do algoritmo genético, representando uma cadeia de caracteres. Além da forma básica de codificação binária, também pode ser usada uma sequência de letras, de números inteiros ou qualquer sequência de símbolos, desde que a decodificação tenha algum significado para o problema. A codificação conhecida como Representação Matricial é um dos métodos usado para codificação de um caminho do problema do caixeiro viajante. A partir de um problema envolvendo um grafo é preciso codificar uma lista de auxílio, conforme é visto na Figura 4.3. Essa lista é uma matriz que é criada pela seguinte condição: se houver aresta entre o nó i ao nó j, a matriz recebe 1 (um) na posição (i,j), caso contrário recebe 0 (zero). Poderíamos, então, usar a matriz ou concatenar suas linhas para criar uma longa sequência de zeros e uns (BRYANT, 2000, p. 10-11).
  46. 46. 45 Figura 4.3: Codificação da “Representação Matricial”. Outro método é o sequenciamento de caracteres4 de duas maneiras diferentes, conforme é visto na Figura 4.4. O primeiro (a) é uma Sequência Ordenada (C1, C2,...,Cn) o que implica que o caminho vai de C1 a C2 seguindo a ordem até Cn, e retornando para C1. A segunda (b) maneira de representar o problema do caixeiro viajante é com a Notação do Ciclo (Cycle Notation), com uma cadeia de caracteres (C1, C2,..., Cn), no qual o caminho é feito indo da cidade i para cidade Ci, até formar um ciclo (BRYANT, 2000, p. 11). Figura 4.4: Codificação “sequencial”: a) Sequência Ordenada; b) Notação do Ciclo. 4 Em Bryant (2000) os caracteres são números inteiro, mas se usar outros tipos de caracteres indexados com um número inteiro funciona da mesma forma. D A B C Caminho Sequência: C1 C2 C3 C4 índice: A=1, B=2, C=3, D=4 a) Caminho codificado: ACBD A  C  B  D C1  C2  C3  C4 b) (C1, C2, C3, C4) = (C, D, B, A) Caminho codificado: CDBA A  C  B  D 1 3 2 4 C4 ↘ C1 ↘ C3 ↘ C2 A  C C B B  D D A i  Ci i  Ci i  Ci i  Ci 1 C1 3C3 2 C2 4 C4 C D B A A C B D Trajetória do Caminho Trajetória do Caminho D A B C i j A B C D A 0 0 1 0 A  C B 0 0 0 1 B  D C 0 1 0 0 C  B D 1 0 0 0 D  A Caminho codificado: 0010.0001.0100.1000 Caminho Lista de auxílio Trajetória do Caminho
  47. 47. 46 4.2.2 Aptidão A avaliação do indivíduo é realizada através de uma função que representa o problema, fornecendo uma medida de aptidão para cada indivíduo da população. A função de avaliação para problema PCV deve encontrar o peso do ciclo Hamiltoniano sobre um grafo do problema, ou seja, a soma dos pesos de todas as arestas do ciclo. Sendo o peso de cada aresta a distância entre duas cidades, então o peso (custo) de cada caminho é distância total percorrida pelo caixeiro viajante ao visitar todas as cidades, conforme a equação (4.2). Quanto menor o custo (distância), maior será a aptidão de um cromossomo (caminho) e, portanto melhor será a solução. O objetivo do PCV, portanto, é encontrar uma solução de menor custo (distância). O custo de uma solução (C1, C2,..., Cn) é dado por (4,2), onde n e o número de cidades e d(Ci, Cj) é a distância entre as cidades Ci e Cj. 4.2.3 Operadores de cruzamento Vários métodos de cruzamento foram desenvolvidos para o problema do caixeiro viajante. Esses operadores devem preservar a condição de que todas as cidades devem ser visitadas exatamente uma vez, e sua função deve aplicar permutações de valores, pois o problema PCV é de natureza combinatória. O operador de Cruzamento de Mapeamento Parcial (PMX), do inglês Partially Mapped Crossover, primeiramente seleciona aleatoriamente dois pontos de corte nos cromossomos pais, conforme é visto na Figura 4.5, no qual formam a seção de mapeamento. Em seguida, é feito o mapeamento entre os genes das seções a partir de suas posições, então os genes dos cromossomos dos pais são trocados de acordo com o mapeamento, ou seja, se o mapeamento for feito entre x e y então onde houver x será trocado por y e vice-versa. Assim os pais 1 e 2 forma respectivamente os filhos 1 e 2.
  48. 48. 47 Figura 4.5: Funcionamento do operador PMX. Este cruzamento é mais adequado quando é usado com a representação da Notação do Ciclo, pois preserva mais da estrutura dos pais, ou seja, mais arestas são transferidas para os filhos. No entanto, esta representação pode obter caminhos ilegais, necessitando elaborar uma rotina de reparo para criar caminhos legais (BRYANT, 2000, p. 12-13). O operador Cycle Crossover (CX) cria descendentes cujas posições são ocupadas por elementos correspondentes de cada um dos pais, conforme é visto na Figura 4.6. Inicialmente é feito a escolha do primeiro gene de um dos pais, para permanecer no cromossomo; assim, o próximo gene que permanecerá no primeiro cromossomo será o correspondente do gene atual no segundo cromossomo, de acordo com sua posição. Dessa forma, se o gene atual for x e seu correspondente for y, então o y do primeiro cromossomo permanecerá. Esse procedimento ocorre até retornar ao gene inicial. Completando o ciclo, as posições que não passaram pelo processo são preenchidas com os genes correspondentes do outro cromossomo, sendo este procedimento válido para os dois pais. D  J E  A F  B Mapeamento Pai 1  ABC | DEF | GHIJ Pai 2  GHI | JAB | EFCD Seção de mapeamento Pontos de corte Pai 2  GHI | JAB | EF C D DEF AB J Filho 2  GHI | DEF | AB C J Filho 1: EFCJABGHID Filho 2: GHIDEFABCJ Pai 1  AB C | DEF | GHI J EF JAB D Filho 1  EF C | JAB | GHI D
  49. 49. 48 Figura 4.6: Funcionamento do operador CX. Este cruzamento é mais adequado com a representação de Sequência Ordenada. Este processo assegura que cada cromossomo seja legal, porém é possível que a herança genética dos pais acabe. Isso não é um problema, pois geralmente só ocorre se os pais tiverem alta aptidão, podendo ainda ser uma boa escolha (BRYANT, 2000, p. 14). O operador Order Crossover (OX) parte da escolha de dois pontos de corte e reorganiza o resto dos genes para gerar um caminho válido, conforme é visto na Figura 4.7. Um filho é criado com a seção de um dos cromossomos, completando a parti do segundo ponto de corte, com os genes do outro cromossomo a partir do mesmo ponto, exceto com os genes que se repete na seção inicial. Este mesmo processo é feito para o segundo filhos com a seção do cromossomo do segundo pai. Pai 1: ABCDEFGHIJ Pai 2: GHIJABEFCD ABCDEFGHIJ GHIJABEFCD ABCDEFGHIJ GHIJABEFCD ABCDEFGHIJ GHIJABEFCD ABCDEFGHIJ GHIJABEFCD Filho 1: AHIJEBGFCD Filho 1: Inicio do ciclo Fim do ciclo Cruzamento ABCDEFGHIJ GHIJABEFCD Filho 2: GBCDAFEHIJ Filho 2: ABCDEFGHIJ GHIJABEFCD ABCDEFGHIJ GHIJABEFCD ABCDEFGHIJ GHIJABEFCD
  50. 50. 49 Figura 4.7: Funcionamento do operador OX. Este cruzamento é mais adequado quando é usado com a representação de Sequência Ordenada, pois preserva mais as estruturas ordenadas dos cromossomos dos pais, promovendo assim a herança genética. Além desses, existem outros operadores que se aplicam ao problema do caixeiro viajante, como o operador Matrix Crossover (MX), um operador que usar a representação matricial, e o Modified Order Crossover (MOX), que é semelhante ao operador OX, mas com apenas um ponto de corte (BRYANT, 2000, p. 15-16). 4.2.4 Operadores de mutação Há vários operadores de mutação apropriados para problemas de permutações de valores, até operadores de mutação heurística apropriados para o problema do caixeiro viajante. Alguns operadores de mutação que podem ser usados são: por inserção, deslocamento, intercâmbio recíproco e por inversão. A mutação por inserção é quando há uma seleção aleatória de uma cidade e sua inserção em uma posição aleatória. A mutação por deslocamento é quando selecionamos um subcaminho e insere-o em uma posição aleatória. Temos também intercâmbio recíproco onde há uma escolha de duas cidades aleatórias e há uma troca de posição. O operador de inversão é uma forma diferente de mutação, que consiste na escolha aleatória de Pai 1  ABC | DEF | GHIJ Pai 2  GHI | JAB | EFCD 1º 2 º XXX | DEF | XXXX [EF]C[D]GHIJAB  CGHIJAB JABDEFCGHI Filho 1: XXX | JAB | XXXX GHI[JAB]CDEF  GHICDEF DEFJABGHIC Filho 2:
  51. 51. 50 dois pontos de inversão no cromossomo e em seguida, inverte-se a ordem dos genes entre os dois pontos. Há também operadores de mutação heurística como os operadores 2-opt, 3- opt e Or-opt, que efetuam a recombinação de arestas (subcaminho) se a condição de redução do custo for satisfeita. A diferença entre esses operadores é o número de arestas que sofrem a mutação (BRYANT, 2000, p. 18). 4.3 CONCLUSÃO Algoritmo Genético é uma técnica para busca global, ideal para problema, como o Problema do Caixeiro Viajante, que tem um espaço de busca muito grande. O próximo capítulo apresenta a modelagem do Algoritmo Genético no modelo de programação MapReduce para o Problema do Caixeiro Viajante e sua implementação para o Hadoop.
  52. 52. 51 5 IMPLEMENTAÇÃO Os Algoritmos Genéticos possuem características que não permitem ser exatamente expressa no modelo MapReduce. Para resolver esse problema, foi desenvolvido formas de modelar o AG usando a proposta original da técnica MapReduce. O uso da técnica MapReduce no AG proporciona uma alta capacidade de encontrar um bom resultado em um espaço de busca extremamente grande, podendo resolver problemas complexos como o do PCV. Este capítulo apresenta a modelagem do Algoritmo Genético no modelo de programação MapReduce para o Problema do Caixeiro Viajante. Na seção 5.1 é feita uma análise dos modelos proposto por outros autores para a modelagem do AG. Na seção 5.2 são comparadas as formas e características das modelagens proposta e de outros possíveis modelos. Na seção 5.3 é demonstrada a modelagem do AG para o problema do caixeiro viajante no MapReduce e seu funcionamento. Na seção 5.4 são apresentadas as características da implementação do algoritmo para Hadoop. Na seção 5.5 são relatados os resultados obtidos na simulação do algoritmo. Finalizando com as considerações finais na seção 5.6. 5.1 TRABALHOS RELACIONADOS A técnica MapReduce permite fácil desenvolvimento de aplicações distribuídas, porém muitas aplicações não podem ser exatamente expressa com MapReduce devido suas características. É o caso das aplicações de natureza iterativa, pois não segue o padrão de duas fases do MapReduce (JIN et al., 2008, p 1). Segundo Ekanayake et al. (2010), MapReduce pode ser aplicada em vários campos, como agrupamento de dados, aprendizado de máquina e visão computacional, onde muitos algoritmos iterativos são comuns, como é caso dos Algoritmos Genéticos. Entretanto, para criar as iterações em uma implementação MapReduce é necessário a execução de várias tarefas MapReduce, porém isso gera múltiplos acessos ao sistema de arquivos distribuído, provocando um alto custo de desempenho.
  53. 53. 52 Considerando que a técnica MapReduce não fornece suporte eficiente para as aplicações iterativas, algumas melhorias foram propostas com o uso de extensões, como o Twister (EKANAYAKE et al., 2010) , o HaLoop (BU et al., 2010) e o MRPGA (JIN et al., 2008), implementações que modificam o modelo original para poder implementar a iteratividade. Sendo o Algoritmo Genético uma aplicação iterativa, autores apresentaram pesquisas para modelar o AG usando a proposta original da técnica MapReduce. No trabalho de Verma et al.(2009) foi definido que cada iteração do AG fosse uma tarefa MapReduce separada em que as funções map executassem as operações de avaliação, e as funções reduce o restante das outras operações. Essa mesma modelagem é utilizada no trabalho de Huang & Lin (2010), na implementação de um AG para resolver o problema Job Shop Scheduling Problem5 (JSSP), com objetivo de demonstrar o impacto do tamanho da população no resultado e no tempo de convergência. Outro trabalho que usa a mesma modelagem é de Er & Erdogan (2014), que avalia a aplicação dos Algoritmos Genéticos para resolver o Problema do Caixeiro Viajante usando o framework MapReduce Hadoop; essa mesma linha de pesquisa é utilizada também por Mishra (2011). No trabalho de Keco & Subasi (2012) é apresentado um modelo de paralelização de Algoritmo Genético usando o Hadoop. O modelo usa apenas uma tarefa MapReduce para todas as iterações do AG e também concentra todo o seu processamento na função map, reduzindo a quantidade operação de leitura/gravação no HDFS. Esse modelo foi comparado com o modelo apresentado em Verma et al.(2009), ambos usando o problema OneMax6 . 5.2 MODELO AG EM MAPREDUCE Ao contrário da modelagem proposta por Verma et al.(2009), a modelagem deste trabalho propõe que as iterações do AG sejam criadas em uma única tarefa MapReduce, semelhante ao apresentado por Keco & Subasi (2012). Isso minimiza o acesso ao sistema de arquivos distribuído, reduzindo o custo de desempenho, pois 5 Problema de Sequenciamento de Tarefas. 6 Problema para maximizar o número de variáveis com o valor 1 (um) em uma String Binária.
  54. 54. 53 as iterações do algoritmo ocorrem sobre a memória principal das máquinas presentes na rede de computadores. Na Tabela 5.1 são demonstradas as possíveis formas de se criar as gerações da iteração do AG, com as gerações locais e globais criadas respectivamente pela iteração na função map e reduce. Tabela 5.1: Possíveis formas de modelagem do AG para o MapReduce. Modelagem do AG Iteração (Gerações) Map Combiner Partitioner Reduce Proposta por Verma et al.(2009) Por tarefa MapReduce separada Avaliação da Aptidão Não é utilizado Modificado para partição randômico Seleção, Cruzamento e Mutação Proposta de Verma modificado Gerações Globais Na função Reduce Avaliação da Aptidão Não é utilizado Padrão ou modificação se necessário Seleção, Cruzamento, Mutação e Avaliação Proposta de Keco & Subasi (2012) Gerações Locais na função Map Avaliação, Seleção, Cruzamento e Mutação Não é utilizado Padrão Seleção Combiner Gerações Locais na função Combiner Avaliação da Aptidão Seleção, Cruzamento, Mutação e Avaliação Padrão Seleção Dupla Geração Gerações Locais & Globais Avaliação, Seleção, Cruzamento e Mutação Não é utilizado Padrão ou modificação se necessário Seleção, Cruzamento, Mutação, Avaliação Conforme é visto na Tabela 5.1, a modelagem proposta por Verma et al.(2009) define que cada geração do AG é feita em uma única tarefa MapReduce, mas como pretende-se que todas as gerações sejam criadas em uma única tarefa MapReduce esse modelo é inadequado. Entretanto, modificando esse modelo para que as gerações fossem criadas na fase Reduce não aproveitaria todo o poder do processamento distribuído, acarretando mais tempo para convergência. Para ter mais aproveitamento do sistema distribuído, podem ser usadas iterações na fase Map para criar gerações, como proposto por Keco & Subasi (2012). Isso pode ser feito com as técnicas de agregação local Combiner ou In- Mapper Combining (LIN & DYER, 2010), porém essa abordagem não aproveitaria a diversidade da população que estaria em outras subpopulações. Portanto, para aproveitar todo o poder computacional do MapReduce e a diversidade da população é proposta a modelagem Dupla Geração, que cria gerações locais na fase Map,e gerações globais na fase Reduce.

×