AG MapReduce resolve PCV

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

1
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

2
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

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.

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

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

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

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

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

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

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

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".

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.

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

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.

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

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

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

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

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

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

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).

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

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).

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.

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.

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

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

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

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).

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.

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).

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

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.

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.

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.

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.

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.

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).

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.

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

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

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.

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.

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).

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

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.

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

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

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:

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.

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.

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.

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.

AG MapReduce resolve PCV

Recomendados

Recomendados

Mais conteúdo relacionado

Destaque

Destaque (20)

Semelhante a AG MapReduce resolve PCV

Semelhante a AG MapReduce resolve PCV (20)

AG MapReduce resolve PCV