Escolar Documentos
Profissional Documentos
Cultura Documentos
Castanhal
2017
Antnio Mateus de Souza Nascimento
Galileu Soares Garcia
Castanhal-PA
2017
AGRADECIMENTOS
Agradeo imensamente a Deus por me acompanhar durante todos esses anos, que do
alto da sua infinita bondade me concedeu o privilgio da vida.
Ao meu pai Sr. Francisco Garcia de Sousa (in memoriam), o homem que me ensinou o
amor Cristo, a famlia e o valor da palavra de um homem. Meu muito obrigado a este que
sempre foi meu mentor, amigo e meu pai e a quem eu dedico especialmente este trabalho.
A minha me Sr. Raimunda Paes de Lima Garcia que sempre em meio dificuldades e
sacrifcios incontveis, depositou neste jovem a confiana e, sobretudo, o seu amor. No posso
descrever o amor, o carinho e a dedicao que sinto pela senhora. Tenho imensurvel orgulho
de dizer que sou o seu filho.
Agradeo ao meu orientador e professor talo Flexa Di Paolo que teve pacincia que
muito me ajudou a concluir este trabalho e que, apesar de alguns percalos no caminho, nunca
desistiu de mim.
Ao meu professor e amigo Anderson Costa que me mostrou quanto programar bom
e que me ensinou o verdadeiro valor de um projeto bem desenvolvido, organizado e muito bem
testado.
Agradeo tambm todos os meus professores que durante muito tempo m instruram
e que foram to importantes na minha vida acadmica e no desenvolvimento deste trabalho.
A Universidade do Estado do Par UEPA por permitir acesso ao conhecimento.
E que dizer voc professor Joo Gabriel Lima? Obrigado pl sua pacincia, pelo
incentivo, pela fora principalmente por me receber e conceder um pouco de seu tempo. Suas
instrues me ajudaram no desenvolvimento deste trabalho.
s meus amigos, pls alegrias e tristezas compartilhas. Com vocs, as pausas entre
uma pizza outra melhoram tudo que tenho produzido neste trabalho.
A todos aqueles que de alguma forma estiveram esto prximos de mim, fazendo esta
vida valer cada vez mais.
The emergence of the internet and computer age has provided the exponential growth in the
amount of data that travels on the network and that are stored to facilitate access to this
information. Today, the volume of this data has grown to such an extent that extremely robust
machines are needed to compute this large contingent of data that increases every day, and such
a context becomes known as Big Data. With this in mind, the objective of this work is to mine
data of 18 years of marine chlorophyll concentrations near the Brazilian coast with low cost
computers, using the K-means algorithm in the Apache Hadoop tool, suitable for Big Data
applications. This work also intends to compare the performance of this data mining approach
with the traditional database processing (MySQL), already performed in previous works. The
qualitative information presented was extremely similar, which validates the presented results.
however, as far as processing time is concerned, the approach using Apache Hadoop did not
have a great advantage, presenting processing time very similar to that executed with the
MySQL database. However, implementations using parallel computing can still contribute to
studies in this field of application.
Figura 1 - Produo de artigos de Big Data na revista Social Sciences Citation ..................... 12
Figura 2 - Propriedades do Big Data ........................................................................................ 19
Figura 3 - Etapas do KDD ........................................................................................................ 20
Figura 4 - Exemplo de execuo do K-means .......................................................................... 22
Figura 5 - Arquitetura do Hadoop ............................................................................................ 23
Figura 6 - Caractersticas do HDFS .......................................................................................... 24
Figura 7 - Exemplo de processamento do Modelo Map/Reduce.............................................. 25
Figura 8 - Plataformas da Ferramenta ...................................................................................... 27
Figura 9 - Configurao Bsica da Ferramenta ........................................................................ 28
Figura 10 - Single Node da Ferramenta ................................................................................... 29
Figura 11 - Cdigo de importao das bibliotecas do Hadoop ................................................ 30
Figura 12 - Cdigo de declarao das variveis globais .......................................................... 31
Quadro 1 - Estrutura principal da tabela no banco de dados .................................................... 31
Figura 13 - Amostra dos dados do Centroide e Dados de Concentrao ................................. 32
Figura 14 - Cdigo da classe Map ............................................................................................ 33
Figura 15 - Cdigo do clculo de distncia entre os pontos ..................................................... 33
Figura 16 - Cdigo do clculo do ponto mais prximo do centride ....................................... 34
Figura 17 - Cdigo de sada do Map ........................................................................................ 34
Figura 18 - Cdigo da classe Reduce ....................................................................................... 34
Figura 19 - Cdigo para o clculo do novo centride .............................................................. 35
Figura 20 - Cdigo dos novos centrides no bando de dados .................................................. 35
Figura 21 - Cdigo da classe main ........................................................................................... 36
Figura 22 - Cdigo de importao dos dados para o sistema HDFS ........................................ 36
Figura 23 - Cdigo de Parada do Algoritmo ............................................................................ 36
Figura 24 - Concentrao minerada no MySQL com a mdia do log da concentrao de cada
ms. ........................................................................................................................................... 38
Figura 25 - Concentrao minerada no Hadoop com a mdia do log da concentrao de cada
ms. ........................................................................................................................................... 40
Quadro 2 - Dados Utilizados .................................................................................................... 42
Grfico 1 - Estimativa de tempo de execuo .......................................................................... 43
Grfico 2 - Consumo de CPU ................................................................................................... 44
Grfico 3 - Consumo de Memria ............................................................................................ 45
Grfico 4 - Estimativa de tempo de execuo de Concentrao .............................................. 46
Grfico 5 - Consumo de CPU de Concentrao ....................................................................... 46
Grfico 6 - Consumo de Memria de Concentrao.................................................................47
Figura 26 - 1 ms de concentrao (janeiro de 2015) com MySQL......................................... 48
Figura 27 - 1 ms de concentrao (janeiro de 2015) com Apache Hadoop ............................ 48
SUMRIO
1. INTRODUO............................................................................................................. 9
1.1 PROBLEMTICA ....................................................................................................... 11
1.2 JUSTIFICATIVA ......................................................................................................... 12
1.3 OBJETIVOS ................................................................................................................. 14
1.4 METODOLOGIA ......................................................................................................... 15
1.5 ESTRUTURA DO TRABALHO ................................................................................. 17
2. REFERENICAL TERICO ..................................................................................... 18
2.1 BIG DATA ................................................................................................................... 18
2.2 MINERAO DE DADOS ......................................................................................... 19
2.2.1 AGRUPAMENTO (CLUSTERING) ........................................................................... 21
2.3 APACHE HADOPP ..................................................................................................... 23
2.3.1 HADOOP DISTRIBUTED FILE SYSTEM (HDFS) .................................................. 24
2.4 O MODELO MAP/REDUCE....................................................................................... 24
2.5 CLOUDERA................................................................................................................. 26
3. APRESENTAO DA FERRAMENTA DE BIG DATA PARA MINERAO
DE DADOS EM COMPUTADORES DE BAIXO CUSTO. .................................. 27
3.1 INSTALAO E CONFIGURAO DA VIRTUAL MACHINE ............................ 27
4. MINERAO DE DADOS DE CONCENTRAO DE CLOROFILA
MARINHA COM APACHE HADOOP ................................................................... 30
4.1 VISUALIZAO DOS RESULTADOS DA MINERAO..................................... 37
5. AVALIAO DE DESEMPENHO COMPUTACIONAL E QUALITATIVO DA
FERRAMENTA APACHE HADOOP COM RELAO AO SGBD MYSQL ... 42
5.2 ANLISE COMPUTACIONAL.................................................................................. 42
5.3 DISCUSSO ................................................................................................................ 43
5.3.1 ANLISE QUALITATIVA ......................................................................................... 47
6. TRABALHOS CORRELATOS ................................................................................ 49
6.1 UMA AVALIAO DE DESEMPENHO DOS AMBIENTES DE
PROGRAMAO PARALELA HADOOP E SPARK .......................................................... 49
6.2 MINERAO DE DADOS COM BIG DATA DAS VARIABILIDADES ESPAO-
TEMPORAIS DAS CONCENTRAES DE CLOROFILA PRXIMAS DA COSTA
MARINHA BRASILEIRA ...................................................................................................... 50
7. CONCLUSES ........................................................................................................... 51
7.1 PONTOS FORTES E FRACOS ................................................................................... 52
7.2 TRABALHOS FUTUROS ........................................................................................... 52
REFERNCIAS ..................................................................................................................... 53
APENDICS ........................................................................................................................... 57
9
1. INTRODUO
Como resultado dentre as ferramentas voltadas para o contexto de Big Data, adotamos
o sistema Cloudera e a ferramenta Apache Hadoop framework administrado pela empresa
Apache Software Foundation para a anlise de informaes acerca da Concentrao de
Clorofila Marinha.
No decorrer deste estudo pretende-se identificar como os conceitos atribudos as
ferramentas de Big Data permitem a coleta de dados e a anlise das informaes atravs da
minerao de dados em computadores de baixo custo como estratgia para a extrao de
conhecimento.
O estudo de caso necessrio para a avaliao das ferramentas fora realizado, em sua
totalidade, atravs do estudo das ferramentas, estruturao da base de dados da concentrao
de clorofila marinha nas ferramentas Apache Cloudera e em computadores de baixo custo e
posteriormente minerao dos dados processado nas ferramentas, onde esperamos recolher o
resultado obtido para a anlise eficincia computacional das ferramentas adotadas.
11
1.1 PROBLEMTICA
1.2 JUSTIFICATIVA
De acordo com Diebold (2012), o conceito de Big Data tem apresentado cada vez mais
ocorrncia entre os estudos realizados acerca desse tema, o que consequentemente eleva-se a
importncia e o desenvolvimento de estudos com destaque para este tema.
1.3 OBJETIVOS
Para atingir este objetivo geral, foram definidos os seguintes objetivos especficos:
1.4 METODOLOGIA
A escolha desta temtica surgiu mediante o trabalho realizado pelo professor talo Flexa
Di Paolo acerca da concentrao de clorofila marinha, onde se buscou a criao de uma
metodologia que auxiliasse o trabalho anterior atravs da realizao do processo de minerao
com ferramentas de Big Data.
Para atingir os objetivos propostos foram utilizadas virtualizaes em diferentes
sistemas computacionais com a plataforma Cloudera que, neste ponto, o ambiente que
proporciona toda uma gama de ferramentas que podem ser utilizadas para se trabalhar com Big
Data, e, dentre elas, o Apache Hadoop. Essa virtualizao ser realizada atravs do Virtualbox,
onde os dados sero minerados em dois computadores pessoais e de baixo custo com diferentes
configuraes para a anlise dos aspectos descritos neste trabalho.
Desta forma, a escolha da ferramenta Apache Hadoop se deu devido aos mecanismos
disponibilizados e por esta ser adotada pela comunidade cientifica como estrutura para a anlise
de grandes contingentes de dados (NOGUEIRA, 2015; PENCHIKALA, 2015; HANSEN,
2012).
O repositrio de dados utilizado neste trabalho contm registros sobre a concentrao
de clorofila marinha dividida mensalmente no perodo de 18 anos. Os dados possuem 3.5
milhes de registros, dispostos em formato de arquivo CSV, sendo classificado como uma base
com extenso volume (KIM, 2014).
Neste trabalho realizada a apresentao das ferramentas de Big Data, demonstrando
as etapas necessrias para as configuraes de hardware do sistema e a estruturao dos dados
na arquitetura adotada pela ferramenta, com o intuito de realizar o processo de minerao e, por
fim, a avaliao dos resultados computacionais e qualitativos entre as ferramentas utilizadas
neste cenrio.
Para a minerao de dados com a ferramenta Hadoop ser empregada a IDE de
programao NetBeans para o desenvolvimento do algoritmo k-means em conjunto com as
funes Map/Reduce, onde ser desenvolvido em um projeto baseado na linguagem de
programao Java.
Este estudo constitui-se de uma abordagem qualitativa, na relao dos resultados obtidos
com a ferramenta Hadoop e MySQL, visando assim as descries espao-temporais destes
modelos de processamento.
16
2. REFERENICAL TERICO
Aps a escolha do tema, estudos foram realizados para obteno das informaes a
respeito do conceito de Big Data e sobre a ferramenta Apache Hadoop que sero apresentadas
nas subsees abaixo.
O conceito de Big Data pode ser definido como o processamento de um amplo volume
de dados produzidos por diferentes aplicaes sendo elas de origem cientfica, dados mdicos
e biolgicos est ser o enfoque deste estudo ou aplicaes voltadas para a rea de
engenharia, onde se faz notria a necessidade da extrao do conhecimento a partir de uma
grande massa de dados (VIEIRA et al, 2012).
Segundo Alecrim (2013) o termo Big Data est relacionado com cinco fatores
conhecidos como os 5 Vs do Big Data, sendo eles:
Volume: Quantidade de informaes e dados produzidas por diferentes aplicaes
Velocidade: O tempo necessrio para o processamento e o tratamento dos dados
oriundos das aplicaes.
Variedade: Os volumes de informaes so oriundos da diversidade das aplicaes,
isto , podemos ter dados estruturados armazenados em banco de dados como MySQL ou
PostgreSQL, e dados no estruturados obtidos de diferentes fontes como documentos, udios e
assim por diante.
Veracidade: Este fator est relacionado com a confiabilidade dos dados, em outras
palavras, necessrio que os processos a partir do Big Data possam garantir a mxima
consistncia dos dados.
Valor: Ester termo est ligado importncia dos dados obtidos mediante os processos
realizados dentro de uma aplicao de Big Data, ou seja, o valor dado aos resultados obtidos.
A partir destes fatores entende-se que o conceito de Big Data no trata apenas desse
amplo volume de dados, mas que estes outros fatores correspondem ao contexto onde se espera
obter determinados resultados. As solues presentes dentro deste contexto precisam trabalhar
com a distribuio de processamento e a elasticidade, ou seja, deve-se entender que estas
aplicaes devem trabalhar com dados que crescem consideravelmente em um curto espao de
tempo.
19
tem se mostrado bastante til nas mais diversas reas, como medicina, finanas,
comrcio, marketing, telecomunicaes, meteorologia, agropecuria,
bioinformticas, entre outras.
O conceito de Minerao de Dados apresentado por Fayyad et al. (1996), afirmam que
a Minerao de Dados ou Data Mining uma etapa do processo de KDD que consiste em aplicar
poderosos algoritmos de anlise e descoberta de dados que produzem padres acerca destes
dados.
A princpio, a minerao de dados era concebida como um sinnimo de Knowledge
Discovery in Databases (KDD) ou Descoberta de Conhecimento em Banco de Dados
(GALVO; MARIN, 2009), mas na verdade, tratava-se de uma das etapas desse processo,
estando na quarta posio e sendo antecedidas das etapas de Seleo, Pr-Processamento e
Transformao.
Ainda no existe uma relao unanime entre o KDD e o processo de minerao de dados.
Para REZENDE (2005) ambos os processos podem ser considerados parecidos. De acordo com
o Fayyad (1996), o KDD faz referncia a todo o processo de descoberta de conhecimento e a
minerao de dados uma das etapas deste processo, no entanto, segundo Oliveira; Silva
(2009), ambos os autores concordam que o processo de minerao deve ser iterativo e dividido
em estgios. Na figura abaixo podemos ver a representao deste processo
Para a minerao de dados, onde se tem conhecimento das classes as quais cada coluna
pertence, so utilizados mtodos de aprendizagem supervisionada, que so classificados como
algoritmos preditivos, pois sua utilizao pressupe que sejam fornecidas previses ou
21
tendncias, explicitando informaes que se encontram implcitas nos dados em que foram
aplicados (Di PAOLO, 2015). Tarefas de minerao de dados pertencentes a este modelo so:
Quando no se tem conhecimento das etiquetas dos dados que se pretende trabalhar e
nem o conjunto de classes a ser analisada, so utilizados os mtodos de aprendizagem no
supervisionada. Tarefas de minerao de dados pertencentes a este modelo so:
De acordo com Witten; Frank (2005) este algoritmo de agrupamento muito robusto e
eficiente. No difcil provar que o processo minimiza a distncia quadrtica total de cada
ponto do grupo ao seu centride (OLIVEIRA, 2009), no entanto, o que se faz iniciar o
23
algoritmo repetidas vezes, com diferentes centrides e escolher aquele resultado com menor
distncia quadrtica total.
recebidas em tuplas ainda menores, facilitando o processamento desses dados. Como o prprio
nome demonstra, a funo Reduce vem sempre depois da Map. (IBM, 2017)
O Map/Reduce teve seu surgimento provocado pela necessidade que empresas tinham
de processar seus dados que j possuam um volume muito grande. Para isso, a computao
precisava ser distribuda e executada paralelamente.
2.5 CLOUDERA
Partindo do que foi abordado nos captulos anteriores, as ferramentas utilizadas para o
desenvolvimento deste estudo visam proporcionar a aplicao dos dados de concentrao de
clorofila marinha em computadores de baixo custo, para tanto, os seguintes processos
apresentados neste captulo sero adotados para a estruturao dos dados e, posteriormente,
minerao de dados nas aplicaes.
O passo inicial para a implementao dos dados a serem utilizados neste estudo se
concentra na instalao da ferramenta Cloudera e das configuraes necessrias para o melhor
aproveitamento do hardware do sistema.
Em relao ao sistema operacional utilizado para a virtualizao da ferramenta ser
usada uma distribuio Linux, mas especificadamente o Ubuntu na verso 14 LTS como
mquina hospedeira. Outro ponto fundamental o hardware a ser empregado para o
processamento dos dados na ferramenta.
Neste contexto, a mquina empregada para o processamento dos dados conta com um
processador Intel Core i7 3 Gerao, 4.0 GHz, HD SSD de 220 GB e 16 GB de RAM,
onde, segundo a prpria desenvolvedora, o adequado para o funcionamento da ferramenta.
A prxima etapa declarar algumas variveis globais que sero usadas em todo cdigo
e que possuem caractersticas fundamentais para a execuo do algoritmo.
A varivel JOB_NOME refere-se ao parmetro dado para cada job a ser executado no
K-Means e serve como um arranjo a partir da representao das funes Map/Reduce. O
SPLITTER representa como o algoritmo deve ler cada coluna de dados, isto , a cada TAB no
arquivo de dados o K-Means interpretar este comando com um separador de dados/colunas.
Neste primeiro bloco de cdigos, para finalizar, a varivel mCentroides transforma os
centrides em uma lista de array de Doubles, isto , o algoritmo armazena o conjunto de
centrides fornecidos pela ferramenta como um conjunto de dados a serem usados nas funes
de processamento do algoritmo.
Feita a estruturao dos arquivos utilizamos primeiramente a funo Map que ser
responsvel por calcular a distncia entre cada ponto e o seu centride. De acordo com
PICHILIANI (2006) a parte mais pesada dos clculos acontece nessa etapa, pois se temos um
grande volume de dados temos que multiplicar este quantitativo de dados pelo nmero de
grupos que desejamos clusterizar estas informaes.
33
Figura 24 - Concentrao minerada no MySQL com a mdia do log da concentrao de cada ms.
Fonte: Di Paolo (2015).
39
Aps esta anlise, a figura 25 apresenta os resultados obtidos com a ferramenta Apache
Hadoop considerando tambm os pares latitude e longitude e todas as colunas representando os
meses do ano.
40
Figura 25 - Concentrao minerada no Hadoop com a mdia do log da concentrao de cada ms.
Fonte: Prprios Autores (2017).
41
Com base nos resultados alcanados, alguns experimentos foram realizados como forma
de avaliar o desempenho da ferramenta Hadoop em relao ao processamento executado com
sistemas gerenciadores de banco de dados tradicionais.
De acordo com (HENNESSY, 2011 apud NOGUEIRA, 2015) o desempenho depende
das mtricas a serem estabelecidas para o que se pretende avaliar.
A anlise destas mtricas se baseia na execuo do algoritmo K-Means, levando em
contas alguns aspectos sugeridos por Nogueira (2015) que podem ser usados como parmetros
para avaliao desta ferramenta. Para este contexto manteremos a ateno para o tempo gasto
na execuo completa do algoritmo nos dois ambientes, contendo tambm o acesso a memria
e o tempo de utilizao da CPU.
Para executar esta avaliao sero utilizados dois sistemas computacionais de pequeno
porte e de uso pessoal com as seguintes configuraes:
Notebook Dell, processador Intel Core i7 4 Gerao, rodando 2.4 GHz,
HD SATA de 500 GB e 8 GB de RAM
Desktop PC, processador Intel Core i7 4 Gerao, rodando 4.0 GHz, SSD
de 220 GB e 16 GB de RAM
43
5.3 DISCUSSO
MySQL Hadoop
32,1
TEMPO EM MINUTOS
9,6
8,3
8,1
Em importante ressaltar que de acordo com este grfico que os melhores resultados so
apresentados pela ferramenta Apache Hadoop com base no hardware do Desktop, no entanto,
apesar da notria diminuio do tempo de execuo do algoritmo com este hardware, os dados
demonstram que claramente possvel alcanar os mesmos resultados com um sistema
computacional de menor robustez.
Outro aspecto a ser levantado nesta avaliao so os recursos consumidos para o
processamento destes dados. No grfico 2 e 3 so apresentados os grficos referentes a
minerao de 1 (um) ms de concentrao de clorofila, avaliando-se a utilizao de CPU e
memria durante o processamento dos dados.
MySQL Hadoop
92,5
82,8
64,3
54,6
VALORES EM %
MySQL Hadoop
98,5
97,8
VALORES EM %
91,5
89,6
NOTEBOOK DELL 8 GB DESKTOP PC 16 GB
MySQL Hadoop
6,28
5,12
4,3
TEMPO EM HORAS
1,52
NOTEBOOK DELL 8 GB DESKTOP PC 16 GB
Com relao a ferramenta Hadoop notou-se uma demanda ainda maior de tempo ao
executar o processamento, haja em vista que fatores como o algoritmo montado para a
minerao de dados, (NOGUEIRA, 2015) a procura pelos dados em disco e transferncia de
informaes acabam impactando como um todo no Hadoop.
MySQL Hadoop
98,5
96,8
VALORES EM %
92,3
91,6
MySQL Hadoop
98,5
97,8
VALORES EM %
95,3
94,6
NOTEBOOK DELL 8 GB DESKTOP PC 16 GB
Outro ponto sensvel nesta avaliao est relacionado ao aspecto qualitativo dos
resultados minerado pela ferramenta Hadoop. Nas figuras 26 e 27 apresentamos o resultado da
minerao com aproximadamente 300 mil registros realizada pelas ferramentas MySQL e
Apache Hadoop.
48
Conforme apresentado no captulo 4.1 deste trabalho, a anlise dos espaos temporais
da ferramenta Hadoop, em relao ao resultado gerado pelo SGBD MySQL, demonstram que
apesar de existirem algumas diferenas, a dinmica de concentrao e concentrao foram
devidamente identificadas.
Nota-se, tambm, uma clara regularidade no comportamento dos grupos, sugerindo,
assim, uma certa eficcia do resultado do Hadoop.
49
6. TRABALHOS CORRELATOS
De acordo com Nogueira (2015) a mudana na arquitetura dos computadores tem levado
ao desenvolvimento de novas tcnicas de processamento e na utilizao de ferramentas
adequadas para a manipulao de grandes quantidades de dados.
O trabalho correlato proposto tem como autor Pedro Micael Theos Lucas Nogueira e
enfoca-se no contexto de Ferramentas de Big Data como artefato fundamental para o
processamento de dados semiestruturados ou no estruturados.
Segundo o autor deste estudo ao analisar separadamente cada uma das ferramentas de
Big Data e relaciona-las atravs de um processamento paralelo afirma que tais mecanismos
podem ser avaliados seguindo mtricas como o tempo de acesso ao disco, memria e o tempo
de uso da CPU, entre outros.
O autor ainda afirma que ferramentas Hadoop e Spark devem ser avaliadas, em relao
ao seu desempenho, atravs de mtodos nomeados como speedup e a eficincia do
processamento paralelo de ambas as ferramentas atravs da utilizao de frmulas matemticas.
Finalmente apresentado o resultado das avaliaes de desempenho das ferramentas no
contexto de Big Data e que refletem um melhor proveito no processo de escolha mais adequada
para a situao onde se deseja do aplicar as ferramentas.
50
7. CONCLUSES
FRACOS FORTES
Processamento paralelo inexistente Minerao dos dados utilizando ferramentas
para Big Data em computadores de baixo
custo.
Virtualizao da ferramenta impactando na Aproximao entre o ambiente de Big Data
diminuio do hardware disponvel para o e os pequenos usurios (estudantes e
procedimento. pesquisadores).
Necessidade de um hardware mais robusto Demonstrao da falta de necessidade de se
para minerar em paralelo adquirir um hardware robusto para comear
a estudar e trabalhar com o ambiente de BIG
DATA
A diferena de tempo de processamento Fcil adaptao do algoritmo Kmeans
entre a ferramenta MySql e o apache juntamente com o Apache Hadoop para
Hadoop qualquer soluo que se faa necessria.
Possibilidade de se trabalhar com os dados
de vrias formas e finalidades diferentes.
REFERNCIAS
APACHE. Apache Hadoop Next Gen Map/Reduce (YARN), 2013. Disponvel em:
<http://hadoop.apache.org/docs/r0.23.10/hadoop-yarn/hadoop-yarn-site/YARN.html>
Acessado em: 27 nov. 2016
CASTRIOTTO, Thiago. A importncia dos tutoriais na internet, 2015. Disponvel em: <
http://www.webartigos.com/artigos/a-importancia-dos-tutoriais-na-internet/135620/>. Acesso
em: 26 out. 2016.
DI PAOLO, talo Flexa. Minerao de dados com Big Data das variabilidades espao-
temporais das concentraes de clorofila prximas da costa marinha brasileira. Campus
Universitrio do Guam UFPA, 2015.
GIOVANNI. GES DISC Goddard Earth Schience Data and Information Services, EUA,
2014. Disponvel em: <http://disc.sci.gsfc.nasa.gov/giovanni/overview/index.html>.
Acesso em: 20 set. 2016.
HANSEN, Christer A. Optimizing Hadoop for the cluster, 2012. Disponvel em: < http://
citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.486.1265&rep=rep1&type=pdf>. Acesso
em: 26 out. 2016
HANSON, Jeffrey. Uma Introduo ao Hadoop Distributed File System, 2013. Disponvel
em: <https://www.ibm.com/developerworks/br/library/wa-introhdfs/>. Acesso em: 26 out.
2016
HEKIMA. Voc sabe o que Big Data Analytics, 2016. Disponvel em: < http://www.
bigdatabusiness.com.br/voce-sabe-o-que-e-big-data-analytics/>. Acesso em: 25 out. 2016.
NOGARE, Diego. Quero trabalhar com Big Data, 2014. Disponvel em: <http://www.diego
nogare.net/2014/06/quero-trabalhar-com-big-data-como-fao/>. Acesso em: 15 nov. 2016.
PENCHIKALA, Srini. Big Data com Apache Spark, 2015. Disponvel em: < https://www.
opservices.com.br/big-data-analytics/>. Acesso em: 22 out. 2016.
PICHILIANI, Mauro. Data Mining na Prtica: Algoritmo K-Means, 2006. Disponvel em:
<https://imasters.com.br/artigo/4709/sql-server/data-mining-na-pratica-algoritmo-k-
means/?trace=1519021197&source=single>. Acesso em: 04 abr. 2017.
RIBEIRO, Claudio Jose Silva. Big Data: os novos desafios para o profissional da
informao. 2014. Disponvel em: <http://periodicos.ufpb.br/ojs/index.php/itec/article
/view/19380>. Acesso em: 16 set. 2016.
SANTOS, Renato P. Big Data: uma nova proposta didtica no ensino de cincias atravs
de ferramentas pblicas e gratuitas, 2013. Disponvel em: < https://www.researchgate.net
/publication/253234152_Big_data_uma_nova_proposta_didatica_no_ensino_de_ciencias_atra
ves_de_ferramentas_publicas_e_gratuitas>. Acesso em: 28 out. 2016.
SAS, Sistema. O que Big Data, [2012?]. Disponvel em: < http://www.sas.com
/pt_br/insights/big-data/what-is-big-data.html >. Acesso em: 16 set. 2016.
YIN, R. K. Estudo de caso: planejamento e mtodos. 3 ed. Porto Alegre: Bookman, 2005.
library/contest/dw-freebooks/Tim_Hieu_Big_Data/Understanding_BigData.PDF>. Acesso
em: 02 nov. 2016.
ZIKOPOULOS, Paul C. Understanding Big Data: Analytics for Enterprise Class Hadoop
and Streaming Data, 2011. Disponvel em: < https://www.ibm.com/developerworks/vn/
library/contest/dw-freebooks/Tim_Hieu_Big_Data/Understanding_BigData.PDF>. Acesso
em: 03 nov. 2016.
APENDICS
import java.io.IOException;
import java.util.*;
import java.io.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.DecimalFormat;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapred.*;
import org.apache.hadoop.mapred.Reducer;
Class.forName(DRIVER);
stmt = conn.createStatement();
return conn;
"/centroidSaida.txt";
public static String OUTPUT_ ARQUIVO_NOME = "/part-00000";
public static String DATA_FILE_NAME =
"/concetracao_concentrao.txt";
public static String JOB_NOME = "KmeanHadaoop";
public static String SPLITTER = "\t";
public static List<Double> mCentroides = new ArrayList<>();
/*
CONFIGURE CRIA CENTROIDE
ATE QUE A DISTANCIA SEJA != 0,1
O MAP CALCULA AS DISTANCIA
O REDUCE CALCULA O NOVO CENTROIDE */
*/
public static class Map extends Map/ReduceBase implements
Mapper<LongWritable, Text, DoubleWritable,
DoubleWritable> {
@Override
public void configure(JobConf job) {
try {
/* Obter o arquivo do cache distribudo
L-lo e armazenar o centride no ArrayList */
Path[] cacheFiles =
DistributedCache.getLocalCacheFiles(job);
if (cacheFiles != null && cacheFiles.length > 0) {
String line;
mCenters.clear();
try (BufferedReader cacheReader = new
BufferedReader(
new FileReader(cacheFiles[0].toString()))) {
/*
Ler o arquivo dividido pelo divisor e armazenar na lista
Neste caso os os registros/colunas sao separados por um TAB
*/
while ((line = cacheReader.readLine()) != null) {
String[] temp = line.split(SPLITTER);
mCentroide.add(Double.parseDouble(temp[0]));
}
}
}
} catch (IOException e) {
59
/*
* A funo de map ir encontrar o centro mnimo do ponto
e emiti-lo para o redutor
*/
@Override
/* CALCULA A DISTANCIA PRO PONTO */
public void map(LongWritable key, Text value,
OutputCollector<DoubleWritable, DoubleWritable>
output,
Reporter reporter) throws IOException {
String line = value.toString();
double point = Double.parseDouble(line);
double min1, min2 = Double.MAX_VALUE, nearest_center =
mCenters
.get(0);
/*
PARA CADA CALCULO DO CENTROID
DEVE ESCOLHER O NOVO_CENTROIDE (CENTRO MAIS
PROXIMO)
PARA CALCULAR A DISTANCIA
*/
if (Math.abs(min1) < Math.abs(min2)) {
novo_centroide = c;
min2 = min1;
}
}
// Emite o centro mais prximo e o ponto
output.collect(new DoubleWritable(novo_centroide),
new DoubleWritable(point));
}
}
/*
*/
@Override
while (values.hasNext()) {
double d = values.next().get();
points = points + " " + Double.toString(d);
sum = sum + d;
++no_elements;
x++;
}
// Nome da tabela
System.out.println("Executando Kmeans");
/*IN = args[0];
OUT = args[1]; */
String input = IN;
61
// Reiterando at a convergncia
int iteration = 0;
conf.setJobName(JOB_NAME);
conf.setMapOutputKeyClass(DoubleWritable.class);
conf.setMapOutputValueClass(DoubleWritable.class);
conf.setOutputKeyClass(DoubleWritable.class);
conf.setOutputValueClass(Text.class);
conf.setMapperClass(Map.class);
conf.setReducerClass(Reduce.class);
conf.setInputFormat(TextInputFormat.class);
conf.setOutputFormat(TextOutputFormat.class);
FileInputFormat.setInputPaths(conf,
new Path(input + DATA_FILE_NAME));
FileOutputFormat.setOutputPath(conf, new Path(output));
JobClient.runJob(conf);
FileSystem fs = FileSystem.get(new Configuration());
List<Double> centers_next;
try (BufferedReader br = new BufferedReader(new
InputStreamReader(
fs.open(ofile)))) {
centers_next = new ArrayList<>();
String line = br.readLine();
while (line != null) {
String[] sp = line.split("\t| ");
int x = sp.length;
double c = Double.parseDouble(sp[0]);
centers_next.add(c);
line = br.readLine();
}
}
62
String prev;
if (iteration == 0) {
prev = input + CENTROID_ARQUIVO_NOME;
}
Path prevfile = new Path(prev);
FileSystem fs1 = FileSystem.get(new Configuration());
List<Double> centers_prev;
try (BufferedReader br1 = new BufferedReader(new
InputStreamReader(
fs1.open(prevfile)))) {
centers_prev = new ArrayList<>();
String l = br1.readLine();
while (l != null) {
String[] sp1 = l.split(SPLITTER);
double d = Double.parseDouble(sp1[0]);
centers_prev.add(d);
l = br1.readLine();
}
}
Iterator<Double> it = centers_prev.iterator();
for (double d : centers_next) {
double temp = it.next();
/*
CASO A DISTANCIA SEJA = 0,1 O ALGORITMO PARA PORQUE
ALCANCOU A SUA CONVERGENCIA, OU SEJA,
A DISTANCIA ENTRE OS PONTOS E O O CENTROIDE E A MINIMA
POSSIVEL
*/
if (Math.abs(temp - d) <= 0.1) {
isdone = true;
} else {
isdone = false;
break;
}
}
if (isdone == true) {
abrir();
63
fs.open(ofile)))) {
centers_next = new ArrayList<>();
String line = br.readLine();
int z = 1;
while (line != null) {
String[] sp = line.split("\t| ");
int x = sp.length;
double c = Double.parseDouble(sp[0]);
centers_next.add(c);
line = br.readLine();
try {
stmt.execute("INSERT INTO teste_clim (centroid,
concentracao)
VALUES(" + centroid + "," +
Double.parseDouble(sp[y]) + ")");
Logger.getLogger(KmeansMin.class.getName()).log(Level.SEVERE, null,
ex);
}
z++;
}
}
}
}
++iteration;
again_input = output;
output = OUT + System.nanoTime();
}
}
}
64
import java.io.IOException;
import java.util.*;
import java.io.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.filecache.DistributedCache;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapred.*;
import org.apache.hadoop.mapred.Reducer;
// Conectar ao banco
public static Connection abrir() throws Exception {
// Registrar o driver
Class.forName(DRIVER);
// Capturar a conexo
Connection conn = DriverManager.getConnection(URL, USUARIO, SENHA);
stmt = conn.createStatement();
// Retorna a conexao aberta
return conn;
/*
CONFIGURE CRIA CENTROIDE
ATE QUE A DISTANCIA SEJA != 0,1
O MAP CALCULA AS DISTANCIA
O REDUCE CALCULA O NOVO CENTROIDE */
/*
* Na classe Mapper estamos substituindo a funo configure.
Neste, estamos lendo o arquivo de Cache Distribudo e, em seguida,
armazenando
isso em varivel de instncia "mCenters"
*/
@Override
public void configure(JobConf job) {
try {
/* Obter o arquivo do cache distribudo
L-lo e armazenar o centride no ArrayList */
Path[] cacheFiles = DistributedCache.getLocalCacheFiles(job);
if (cacheFiles != null && cacheFiles.length > 0) {
String line;
mCentroides.clear();
try (BufferedReader cacheReader = new BufferedReader(
new FileReader(cacheFiles[0].toString()))) {
/* Ler o arquivo dividido pelo divisor e armazenar na lista
Neste caso os os registros/colunas sao separados por um TAB
*/
while ((line = cacheReader.readLine()) != null) {
String[] temp = line.split(SPLITTER);
mCentroides.add(Double.parseDouble(temp[0]));
}
}
}
} catch (IOException e) {
System.err.println("Excecao ao ler o Cache Distribuido: " + e);
}
}
/*
* A funo de map ir encontrar o centro mnimo do ponto
e emiti-lo para o redutor
*/
66
@Override
/* CALCULA A DISTANCIA PRO PONTO */
public void map(LongWritable key, Text value,
OutputCollector<DoubleWritable, DoubleWritable> output,
Reporter reporter) throws IOException {
String line = value.toString();
double point = Double.parseDouble(line);
double min1, min2 = Double.MAX_VALUE, nearest_center = mCentroides
.get(0);
/*
while (values.hasNext()) {
double d = values.next().get();
points = points + " " + Double.toString(d);
sum = sum + d;
++no_elements;
lista_valores.add(d);
x++;
}
try {
stmt.execute("UPDATE kmdata209 SET cluster_id = " + newCenter + "
WHERE log = " + lista_valores.get(y) );
} catch (SQLException ex) {
Logger.getLogger(KmeanHadoop.class.getName()).log(Level.SEVERE,
null, ex);
}
abrir();
/*
try {
Class.forName(driverName);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
}
//Conexao
Connection con =
DriverManager.getConnection("jdbc:hive2://localhost:10000/default",
"hive", "");
stmt = con.createStatement();
68
*/
// Nome da tabela
System.out.println("Executando Kmeans");
/*IN = args[0];
OUT = args[1]; */
String input = IN;
String output = OUT + System.nanoTime();
String again_input = output;
// Reiterando at a convergncia
int iteration = 0;
conf.setJobName(JOB_NAME);
conf.setMapOutputKeyClass(DoubleWritable.class);
conf.setMapOutputValueClass(DoubleWritable.class);
conf.setOutputKeyClass(DoubleWritable.class);
conf.setOutputValueClass(Text.class);
conf.setMapperClass(Map.class);
conf.setReducerClass(Reduce.class);
conf.setInputFormat(TextInputFormat.class);
conf.setOutputFormat(TextOutputFormat.class);
FileInputFormat.setInputPaths(conf,
new Path(input + DATA_FILE_NAME));
FileOutputFormat.setOutputPath(conf, new Path(output));
JobClient.runJob(conf);
}
}
String prev;
if (iteration == 0) {
prev = input + CENTROID_FILE_NAME;
} else {
prev = again_input + OUTPUT_FILE_NAME;
}
Path prevfile = new Path(prev);
FileSystem fs1 = FileSystem.get(new Configuration());
List<Double> centers_prev;
try (BufferedReader br1 = new BufferedReader(new InputStreamReader(
fs1.open(prevfile)))) {
centers_prev = new ArrayList<>();
String l = br1.readLine();
while (l != null) {
String[] sp1 = l.split(SPLITTER);
double d = Double.parseDouble(sp1[0]);
centers_prev.add(d);
l = br1.readLine();
}
}
Iterator<Double> it = centers_prev.iterator();
for (double d : centers_next) {
double temp = it.next();
break;
}
}
++iteration;
again_input = output;
output = OUT + System.nanoTime();
}
}