Indexação de documentos em Java

Departamento de Eletrónica,
Telecomunicações e Informática
Armazenamento, Indexação e
Recuperação de Informação
Trabalho Prático 1
Mestrado em Sistemas de Informação
Docente: Prof. José Luís Oliveira Discentes: Emanuel Pires – 77994
Prof. Sérgio Matos Mário Monteiro – 77910

Armazenamento, Indexação e Recuperação de Informação – MSI – 2015/2016
Mário Monteiro - 77910 || Emanuel Pires - 77994
Índice
INTRODUÇÃO ...........................................................................................................................3
PARTE 1 – ARQUITECTURA E MODELAÇÃO..............................................................................5
PARTE 2 – CORPUS READ .........................................................................................................9
PARTE 3 – TOKENIZER ..............................................................................................................10
PARTE 4 - INDEXAÇÃO ..............................................................................................................10
PARTE 5 – RESPOSTAS AS QUESTÕES.....................................................................................11
PARTE 6 – EXECUÇÃO DO ALGORITMO INDEXAÇÃO...............................................................15
PARTE 6 – CONSIDERAÇÕES FINAIS .......................................................................................17
ANEXO.....................................................................................................................................18

INTRODUÇÃO
Este relatório realiza-se no âmbito da unidade curricular da disciplina Armazenamento
Indexação e Recuperação de Informação do Mestrado em Sistemas de Informação da
Universidade de Aveiro, com o intuito de criar um algoritmo em java com os seguintes
requisitos básicos:
 Criar uma classe capaz de fazer leitura e devolver o conteúdo de vários documentos,
analisando a estrutura do mesmo e removendo as Tags HTML existentes;
 Criar uma classe Tokenizer que devolve Tokens (palavras dentro de um corpus),
procedendo assim a limpeza dos mesmos. Remover os caracteres especiais tais
como: ('.', ',', '-', etc…), tags em HTML/XML, (‘  ’) e outros.
 Criar uma classe Index para criar um índice invertido dos termos (Tokens) obtidos
através do processo de tocanização;
 Responder algumas questões estatísticas como: apresentar os 10 termos mais
frequentes;
 Integrar o algoritmo Porter Stemmer e filtro de StopWords, a fim de fazer limpeza
dos dados;
Será apresentado com grande nível de detalhes a arquitetura, diagrama de classes, bem
como a descrição para cada uma das classes. Encontra-se também um tutorial em anexo a
mostrar como se interagir com o algoritmo.

DESENVOLVIMENTO
Para o desenvolvimento do algoritmo foi sugerido pelo professor a utilização tecnologia
Java.
Java é uma linguagem de programação e plataforma computacional lançada pela Sun
Microsystems em 1995. Esta linguagem está presente desde, laptops a datacenters, consolas
de jogos a supercomputadores científicos, telemóveis e muito mais. Ela encontra-se
disponível de forma gratuita na Internet no site java.com.
Como principal IDE de desenvolvimento, foi escolhido o Netbeans. Este oferece-nos
assistentes e modelos que permitem a criação de aplicações Java EE, Java SE e Java ME.
Para desenvolver este algoritmo tivemos a necessidade de incorporar algumas bibliotecas
como:
 Jsoup-1.8.3.jar1
- Biblioteca feito em Java para trabalhar com serialização de
objetos Json.
 Json-simple-1.1.1.jar2
– Biblioteca que faz tratamento de objetos Json (codificar e
descodificar texto).
 Guava-18.0.jar3
- Biblioteca da Google utilizado para fazer tratamento de: coleções,
caching, apoio primitivas, processamento de string, I/O, no nosso caso ela é
utilizado para fazer o Join do texto Corpus.
 Libstemmer.jar 4
- Algoritmo Porter Stemmer, um processo comum para
terminações morfológicas de palavras em português. Seu principal objetivo é fazer
normalização de palavras em sistemas de recuperação de informação.
1
Http://jsoup.org/packages/jsoup-1.8.3.jar
2
Http://www.java2s.com/Code/Jar/j/Downloadjsonsimple111jar.htm
3
Http://search.maven.org/remotecontent?filepath=com/google/guava/guava/18.0/guava-18.0.jar

PARTE 1 – ARQUITECTURA E MODELAÇÃO
Foi dotado o modelo de classes Orientado a Objetos, para o desenvolvimento deste
algoritmo. Cada uma das nossas classes são implementadas de forma a instanciar threads,
de forma realizar uma operação paralela ou seja, as classes podem ter espaços próprios na
memória e no processador.
4
(http://snowball.tartarus.org/)
Figura 1 – Classes de indexação de Termos

Para uma melhor compreensão da estrutura de classes, é apresentado uma breve discrição
dos mesmos:
 CorpusRead – Classe responsável por fazer carregamento e tratamento de corpus de
cada documento mapeando-os mapeá-la na memória (HashMap).
 Token – Classe responsável pelo tratamento de todos tokens de cada corpus, com a
respectiva contagem de termos.
 IndexThread – Classe que assenta numa estrutura em Thread para carregar os
dados armazenados em disco, faz a execução e tratamento dos termos, verifica
número de ocorrências de cada termo em cada ficheiro e serializa-os para ficheiros
Json. O nome de cada ficheiro Json é formado através da obtenção das 2 primeiras
letras do termo e adicionado ainda o número (Id) do ficheiro em que os termos
ocorrem.
 TokenThread - Classe utilizada no auxílio de tokenização, com maior número de
Thread para contar o número de ocorrências de cada termo dentro de um corpus. A
estratégia passa assenta-se em separar em pedaços o corpus e distribuir cada pedaço
a uma thread (executar em paralelo), para uma maior rapidez da contagem.
 Indexer – classe responsável por toda a indexação, onde é executado todos os
métodos das outras classes apresentadas.

A seguir é apresentada a arquitectura do algoritmo de forma a melhor ter uma noção de
como esta montada.
Para realizar a operação de indexação foi fornecida em disco um conjunto de ficheiros de
textos (corpus). O algoritmo desenvolvido aplica sobre esses corpus o princípio de divisão
para que seja utilizado menos memória possível e com menor quantidade de dados para
processar a velocidade do mesmo é maior.
Imaginemos numa fábrica onde dois funcionários trabalham na mesma linha de produção:
isso seria o equivalente a um processador dual-core. Caso o gerente tiver que mandar uma
tarefa apenas para o primeiro operário, o segundo fica sem ter o que fazer. Desta forma só o
primeiro operário fica a trabalhar.
Figura 2 - Arquitetura do algoritmo

Para resolver esse problema, o gerente pode dividir a tarefa em duas partes e mandado
ordenado assim que cada um fizesse uma parte do trabalho. Dessa maneira, o processo seria
concluído em menos tempo e com maior eficácia.
Onde queremos chegar com esse exemplo? Simples: o algoritmo desenvolvido segue o
mesmo modelo que o gerente deve tomar para dividir tarefas aos seus operários. Neste caso
o que o algoritmo foi treinado a fazer é a repartição de dados em vários blocos, cada bloco
ainda é subdividido de forma a partilhar os mesmos aos vários threads tornando os mais
eficientes do que sobrecarrega-los com grande quantidade de dados na memoria. Em java
cada threads tem uma quantidade de memória limitada e uma instanciação de processador
reservado, permitindo assim a sua execução em paralelo e independente de qualquer outro
processo.
Depois de realizar toda operação de divisão dos ficheiros em blocos, os blocos são tratados
pelas Threads que se encarregam de fazer limpeza de caracteres especiais, e armazena-os
numa estrutura em HashMap, cada uma desta estrutura é armazenado no disco de forma a
libertar o espaço de memória, de mesmo modo as threads são liberadas forma estarem
prontos para executarem novas tarefas.
Os dados armazenados em disco são processados por outras threads para realizar a
tokenização, cada bloco no disco é carregado e um outro processo faz a contagem dos
termos para cada corpos devolvendo-os numa estrutura em Json de forma a ser armazenado
no disco.
Para melhor compreender todo o processo foi criada o seguinte diagrama de fluxo de dados
que representa todo o algoritmo de uma forma abstracta.

PARTE 2 – CORPUS READ
Um dos requisitos do trabalho é criar uma classe capaz de fazer leitura de corpus e devolver
o conteúdo de vários documentos, analisando a estrutura do mesmo e removendo os
caracteres especiais existentes (tags HTML etc…).
A leitura dos ficheiros é feita através da divisão de corpus em vários pequenos segmentos
de forma a realizar toda as operações de leitura e tratamento dos conteúdos dos ficheiros
em paralelo entre as várias Threads. Para que o processo seja eficiente tanto na utilização
do processador quanto da memória.
A leitura de corpus é armazenada em várias estruturas de memória (HasMap) de forma a
facilitar o acesso do mesmo pelas várias threads que realizam a operação de tokenização.
Essas estruturas são armazenadas em dico a cada iteração, com vista a melhor a
performance do algoritmo. Após isso existe as threads auxiliares para carregar um a um, e
realizar o tratamento em memória. Ficam a trabalhar em paralelo com a leitura de corpus.
Figura 3 – Diagrana de fluxo de dados

PARTE 3 – TOKENIZER
Tokenizer tem como objetivo, criar uma classe token que devolve os tokens de um dado
corpus, sabendo que deve ignorar os caracteres especiais ('.', ',', '-', etc.) como também
entidades HTML e/ou XML (‘ ’ e outros).
Para o efeito, foi desenvolvido no algoritmo uma classe que executa o processo de leitura
no disco, dos corpus armazenados temporariamente, carregar cada um deles e realizar
operação de contagem de ocorrências dos mesmos dentro de cada corpus.
Sabendo que os corpos compõem uma grande quantidade de termos, processa-los de uma
vez só tornaria o algoritmo pouco eficiente, o consumo de memória e o acesso ao
processador pode ser excessivo. Por isso esses termos são divididos em vários segmentos e
distribuídos em várias threads conforme o número de segmento criado, proporcionando
assim uma maior velocidade no processamento.
Como resultado, o processo irá retornar os termos e o número de vezes que estas ocorrem
para cada corpus. O mesmo será enviado para outras threads com finalidade de criar uma
estrutura em Json, realizando a operação de indexação, com termos e o número de vez que
estes encontram-se a cada ficheiro.
PARTE 4 - INDEXAÇÃO
O objectivo principal de todo o algoritmo é criar indexação de índice invertido. Para o feito
foi criado uma classe de Index que executa todas as classes anteriores e armazena em disco
a indexação realizada.
O ficheiro indexado é gerado através de um método que pega nas duas primeiras letras do
termo e mais um número adicional para diferenciar os vários segmentos do mesmo que foi
criado. Foi utilizado este princípio de forma a liberar a memória e processador a cada grupo
de iteração de indexação e facilitando um processamento muito mais rápido de pesquisa.

A figura seguinte apresenta a estrutura do índice invertida criada. Na estrutura, um termo
pode estar incluído em mais do que um ficheiro Json, pois na pesquisa em vez de ser aberta
um único documento para o processamento deve ser acedida os 3 para realizar o processo.
A vantagem dessa filosofia prende-se com a rapidez de execução, pois teremos cada
ficheiro Json a ser processado num processo ou threads independentes para a respetiva
pesquisa, ver em anexo.
Figura 4 – Estrutura do Índice invertida criada
PARTE 5 – RESPOSTAS AS QUESTÕES
O algoritmo realiza a limpeza de dados através de remoção de alguns termos (palavras) que
são encontrados na lista de StopWords e utilizando ainda o algoritmo de Steamer, de forma
a normalizar os termos. Foi combinado diferentes formas de execução do algoritmo com
finalidade de criar estatísticas acerca do desempenho e quantidade de termos indexados
através do algoritmo. Isto Pode ser analisado na tabela que se segue, com os resultados

obtidos através da combinação da limpeza dos Stop Words e a inclusão ou não do algoritmo
Steamer.
Modo Execução
Tempo
(Minuto)
Número de
Termos
Tempo Inicial Tempo Final
Com remoção do Stop
Words e Steamer
3,8 89358 19:30:55 19:34:45
Sem remoção do Stop
Words e com Steamer
5,45 162708 19:37:01 19:42:28
Com remoção do Stop
Words sem execução do
Steamer
4,02 89358 19:43:56 19:47:57
Sem remoção do Stop
Words e sem execução
do Steamer
5,33 162708 19:48:33 19:53:53
Tabela I - Tabela estatística de indexação com remoção do StopWords e aplicação do algoritmo Steamer.
O tempo inicial referido na tabela acima representa o tempo em que o algoritmo foi
iniciado e o tempo final, representa o tempo em que o algoritmo termina execução.
Para uma melhor apreciação dos resultados final, foi gerado dois gráficos, um
representando o tempo que o algoritmo levou para fazer indexação dos termos de acordo
com aplicação dos dois métodos citados acima e um outro gráfico, representando a
quantidade de termos indexados aplicando os tais métodos.

Gráfico I - tempo gasto para executar o algoritmo tendo em conta a combinação dos métodos
(remoção de StopWords e aplicação do algoritmo Steamer)
Gráfico II - Quantidade de termos indexado tendo em conta a combinação dos métodos (remoção de StopWords e
aplicação do algoritmo Steamer.
0,00
1,00
2,00
3,00
4,00
5,00
6,00
com remoção do
StopWords e
Steamer
sem remoção do
StopWords e
Steamer
com remoção do
StopWords sem
execução do
Steamer
sem remorção do
StopWords e
com execução do
Steamer
Minutos
Tempo (Minuto)
Tempo (Minuto)
0
20000
40000
60000
80000
100000
120000
140000
160000
180000
com remoção
do StopWords e
Steamer
sem remoção
do StopWords e
Steamer
com remoção
do StopWords
sem execução
do Steamer
sem remorção
do StopWords e
com execução
do Steamer
QuantidadedeTermos
numero de Termos
numero de Termos

Apos toda a operação de indexação deve ser criada uma tabela com os 10 termos mais
frequentes e Listar os 10 word/document pares com a maior proporção de frequência
para frequência documentos.
Lista top 10 termos mais frequentes
Termos Quantidade
comissao 246093
senhor 237524
sobre 183618
presidente 177332
tambem 176957
europeia 172631
uniao 152724
parlamento 141151
conselho 117673
relatorio 115315
Tabela II. Lista dos 10 termos mais frequentes.
Lista top 10 > Frequência Words/Documents
Termos Frequência
juizreal 35.5
vexagost 35.064575
msy 35.0
julgass 29.0
epla 28.0
optingin 24.0
exostr 22.0
contrap 21.0
holodomor 20.333334
planalt 20.0
Tabela III. Lista dos 10 frequência Words/Documents.

PARTE 6 – EXECUÇÃO DO ALGORITMO INDEXAÇÃO
Ao arrancar o algoritmo, é apresentado um menu, com algumas opções a fim de ajudar-
nos na execução do mesmo. No menu inicial é apresentado algumas opções como:
Executar a indexação e apresentar os relatórios, vide figura seguinte.
Após escolher a opção executar Indexação é apresentada as opções de execução.
Opção 1 [Desativar] Stopwords, significa que o algoritmo vai ser executado removendo do
corpus todos os Stopwords, caso se pretenda deixar os Stopwords nos corpos deve ser
escolhida esta opção, o utilizador pode ativar ou desativar execução de Stopwords.
Opção 2 [Desativar] Steamer, significa que o algoritmo vai ser executado aplicando
algoritmo de Steamer sobre os termos, caso se pretenda deixar os termos sem aplicar o
Steamer deve ser escolhida esta opção.
Opção 3 pode ser escolhida os dois modos de execução ao mesmo tempo. E opção 4 é para
arrancar com a execução em si. Durante a execução aparece no output o tempo de início e
os números de grupos de corpus em execução, ao terminar a indexação aprece o tempo
final. Vide a figura seguinte.
Figura 4 – Menu principal do algoritmo

Após a execução de toda a indexação, como um dos requisitos e apresentar relatórios, para
o efeito tem se o seguinte menu.
A opção 1 – carregar para a memória o conteúdo com as listas de termos e respectivas
quantidades de ocorrências, caso não estiver disponível na mesma.
A opção 2 - apresentar a informação com os 10 termos com maior ocorrência.
A opção 3 - apresentar a 10 frequência Termos/Documentos.
Figura 5 – Menu modo execução
Figura 6 – Menu relatório

PARTE 6 – CONSIDERAÇÕES FINAIS
Este trabalho propôs-se como objectivo geral criar uma estrutura de indexação invertida
em java, para que o trabalho não se limitasse a um simples algoritmo de indexação pouco
eficiente em termos de recursos e tempos, foi realizado um conjunto de pesquisa e acções
de forma a torna-lo num algoritmo eficiente na utilização dos recursos e com um tempo
de execução razoável.
Este tempo pode ser melhorado muito ainda mais com um uma unidade de
processamento e memória maior, aumentando o número de corpos a processar a cada
bloco de corpos.
Filosofia de segmentação e multiprocessamento adoptada pode se dizer que em termos
de performance do algoritmo o ganho foi brutal, visto que com o multiprocessamento dos
corpos em segmentos teremos pouca utilização da memória e uma melhor eficiência no
uso do processador, bem como a operação de pesquisa sobre o Índice invertido criado.
A nível de eficiência o maior ganho em termos de eficiência do algoritmo foi conseguido
nos seguintes pontos:
 Segmentação dos corpos e grupos pequenos, num tamanho razoável para permitir
que não seja sobrecarregada o processador e a memória;
 Segmentação da estrutura de como é criada a indexação em vários segmentos de
ficheiros Json, pois fazendo em apenas um único segmento a utilização dos
recursos essenciais é maior e o acto de pesquisa será menos eficiente sobre a
mesma estrutura.
 Divisão de corpos no processo da contagem de termos, pois com um corpos com
um grande quantidade de termos o tempo de execução torna-se pouco eficiente.
 Não utilização de colectores de lixo (Garbage colector, System.gc() no Java) da
memoria varias vezes, pois o mesmo tende a tornar pouco eficiente o algoritmo,
pois executa varias operações para o efeito.
Podemos dizer que em termos de gestão dos recursos como memória e processador em si
podia se fazer mais um pouco, mais a filosofia de segmentação adoptada permitiu-nos
colmatar esse princípio.

ANEXO
Figura 6 – gestão de memória
Figura 7 – utilização de memória

Resultados da execução do algoritmo com remoção Stopwords e aplicando steamer
Iniciado Processo de indexação em: Mon Oct 19 17:41:03 BST 2015
Processo de indexação Finalizado em: Mon Oct 19 17:46:57 BST 2015
Total de termos com [StopWords e Steamer]: 89418 Termos
Resultados da execução do algoritmo com remoção Stopwords e o steamer desativado
Total de termos com [StopWords e sem Steamer]: 166252 Termos
Resultados da execução do algoritmo com remoção Stopwords desativado e aplicando
steamer
Total de termos com [Steamer e sem StopWords]: 89418 Termos
Resultados da execução do algoritmo com remoção Stopwords desativado e o steamer
também desativado
Total de termos com [Sem StopWords e Steamer]: 166252 Termos

Figura 8 – termos indexados em Json

Indexação de documentos em Java

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (18)

Destaque

Destaque (20)

Semelhante a Indexação de documentos em Java

Semelhante a Indexação de documentos em Java (20)

Mais de Mário Monteiro

Mais de Mário Monteiro (6)

Indexação de documentos em Java