Desenvolvimento de um Módulo de Indexação para Sistemas de

Сomentários

Transcrição

Desenvolvimento de um Módulo de Indexação para Sistemas de
SAMIRA CAMPOS FEITOSA
DESENVOLVIMENTO DE UM MÓDULO DE INDEXAÇÃO PARA
SISTEMAS DE RECUPERAÇÃO DE INFORMAÇÕES WEB
TRABALHO DE CONCLUSÃO DE CURSO
PALMAS
2004
TO
SAMIRA CAMPOS FEITOSA
DESENVOLVIMENTO DE UM MÓDULO DE INDEXAÇÃO PARA
SISTEMAS DE RECUPERAÇÃO DE INFORMAÇÕES WEB
Monografia
apresentada
como
requisito parcial da disciplina Prática de
Sistemas de Informação II (TCC) do
curso de Sistemas de Informação,
orientada pelo Prof. Fernando Luiz de
Oliveira .
PALMAS - TO
2004
SAMIRA CAMPOS FEITOSA
DESENVOLVIMENTO DE UM MÓDULO DE INDEXAÇÃO PARA
SISTEMAS DE RECUPERAÇÃO DE INFORMAÇÕES WEB
Monografia
apresentada
como
requisito parcial da disciplina Prática de
Sistemas de Informação II (TCC) do
curso de Sistemas de Informação,
orientada pelo Prof. Fernando Luiz de
Oliveira .
Aprovada em Julho de 2004.
BANCA EXAMINADORA
_______________________________________________________
Prof. Fernando Luiz de Oliveira.
Centro Universitário Luterano de Palmas
_______________________________________________________
Profª. Parcilene Fernandes de Brito, M.Sc.
Centro Universitário Luterano de Palmas
_______________________________________________________
Prof. Eduardo Leal, M.Sc.
Centro Universitário Luterano de Palmas
PALMAS
2004
... a Deus por estar sempre ao meu lado.
AGRADECIMENTOS
Agradeço primeiramente a Deus, que sempre me guia e auxilia em todos os
momentos de minha vida.
Aos meus pais pela força, estímulo e paciência.
Aos meus amigos, pela ajuda incondicional, principalmente a Daniela, que está
sempre pronta a ajudar.
Ao meu amigo e colega no desenvolvimento deste, Aislan, cuja ajuda foi de grande
valor na elaboração e desenvolvimento deste.
Ao meu orientador Fernando, pela paciência e dedicação em todos os momentos da
realização deste trabalho.
A todos professores deste curso que diretamente ou indiretamente contribuíram
para minha aquisição de conhecimentos.
SUMÁRIO
1. INTRODUÇÃO ...............................................................................................................10
2. REVISÃO DE LITERATURA........................................................................................12
2.1 Recuperando informações...............................................................................12
2.2 Recuperação de Informações na Web .............................................................13
2.3 Sistemas de Recuperação de Informações na Web .........................................15
2.3.1 O Processo de Indexação ..........................................................................19
2.3.2 Trabalhos Correlatos.................................................................................21
2.3.3 Módulo de Indexação................................................................................22
3. MATERIAIS E MÉTODOS............................................................................................24
3.1 Materiais .........................................................................................................24
3.2 Método ............................................................................................................25
4 RESULTADOS E DISCUSSÕES ....................................................................................26
4.1 Visão Geral da Implementação.......................................................................26
4.2 Arquitetura do Sistema ...................................................................................27
4.2.1 Bases de Índices........................................................................................28
4.2.2 Eliminação: Caracteres Especiais, Sinais de Pontuação, Palavras
Irrelevantes e Números ................................................................................................28
4.2.3 Algoritmo para Extração de Radicais (Stemming)....................................29
4.3 Considerações sobre a Implementação ...........................................................29
4.4 Testes ..............................................................................................................35
4.5 Resultados .......................................................................................................38
4.6 Limitações.......................................................................................................39
5 CONSIDERAÇÕES FINAIS ...........................................................................................40
6 TRABALHOS FUTUROS ...............................................................................................41
7 REFERÊNCIAS BIBLIOGRÁFICAS .............................................................................42
8 ANEXOS ..........................................................................................................................44
LISTA DE FIGURAS
Figura 1: Arquitetura Padrão SRI Web ...............................................................................17
Figura 3: Estrutura do Banco, Relacionamentos e Cardinalidade .......................................28
Figura 4: Recuperação das tags importantes para o processo de indexação........................30
Figura 5: Método BuscaTag................................................................................................31
Figura 6: Método BuscaTags ...............................................................................................32
Figura 7: Inserção de Tags Na base de índices ....................................................................32
Figura 8: Método deleteIgnoradas .......................................................................................33
Figura 9: Método deleteCharacter .......................................................................................34
Figura 10: Extração dos Radicais e Sufixos / Armazenamento Base de Índices.................35
Figura 11: Documento a ser Indexado .................................................................................35
Figura 12: Código Fonte Documento Testado.....................................................................36
Figura 13: Extração de tags .................................................................................................36
Figura 14: Tabela de Radicais .............................................................................................37
Figura 15: Tabela de Sufixos ..............................................................................................38
Figura 16: Resultado da Indexação......................................................................................39
LISTA DE ABREVIATURAS
HTML
HiperText Markup Language
HTTP
Hypertext Transfer Protocol
SGBD
Sistema Gerenciador de Banco de Dados
SMART
System for Manipulation and Retrieval of Text
SRI WEB
Sistema de Recuperação de Informações Web
TCP/IP
Transmission Control Protocol / Internet Protocol
TREC
Text Retrieval Conference
URL
Uniform Resource Locator
RESUMO
A grande quantidade de documentos disponíveis na Web tem aumentado
substancialmente o número de pesquisas e propostas que visam facilitar e agilizar as
buscas por informações úteis na Web. Estas pesquisas englobam desde o desenvolvimento
de ferramentas de busca, até formas de melhor representar a informação.
Sendo a palavra a fonte principal de acesso a informação, os Sistemas de
Recuperação de Informações Web buscam cada vez mais, aprimorar seus métodos e
técnicas de forma a garantir a satisfação do usuário quando este realiza uma busca.
Este trabalho propõe o desenvolvimento de uma Estrutura de Indexação, que busca
potencializar o Processo de Indexação através do uso de algoritmos responsáveis pela
extração de radicais, eliminação de palavras irrelevantes, entre outras técnicas. Tendo
como objetivo principal a geração e o gerenciamento de uma base de índices, este trabalho
desenvolve apenas parte de um Sistema de Recuperação de Informação Web, porém, uma
parte de grande importância, visto que todo o resto do sistema trabalha sobre sua estrutura.
ABSTRACT
The large amount of documents on the Web has increased the number of researches
and purposes that wants to facilitate and make fast the searches about excellent
information. This researches enclose the development of search tools, as the best away to
present the information.
As the word is the main source of information access, the Retrieval Information
Web Systems search to make better the methods and techniques to make sure the
satisfaction to the user with their searches.
This work to aim at development a Index Struct, that try to make better the Index
Process through of use algorithms that are responsable by extract radicals, cut out
irrelevant words, among other techniques. As main goal the creation and the management
of a index source, this work develop just part of the Retrieval Information Web System,
but a important part, because the remain of the system work about this struct.
1. INTRODUÇÃO
Com o crescimento do volume de documentos disponibilizados para os usuários
através da rede mundial de computadores e devido a enorme diversidade de conteúdos
encontrado nos mesmos, tornou-se necessário o desenvolvimento de Sistemas de
Recuperação de Informações Web. Uma das maiores dificuldades encontradas por este tipo
de sistema é recuperação rápida e precisa de documentos relevantes às necessidades de
seus usuários.
Segundo MACEDO (2001), encontrar informações úteis na Internet é uma tarefa
considerada complexa, demorada e frustrante para muitos usuários. Isto acontece devido as
imprecisões dos atuais Sistemas de Recuperação de Informações Web (SRI Web) e a
inadequada formulação da consulta feita pelos usuários inexperientes.
Os SRI´s Web, em sua arquitetura padrão, são compostos por três módulos
distintos. O primeiro refere-se ao Módulo Controlador de Robots, que tem por finalidade
percorrer a WWW em busca de novos documentos (páginas), fazer uma cópia dos mesmos
e armazená-los em um repositório de documentos (diretório), mantido por este módulo. O
segundo, Módulo Indexador, tem por objetivo verificar o repositório de documentos criado
pelo Controle de Robots, e para cada documento ali existente, extrair destes as palavras que
melhor identificam seu conteúdo, armazenando estas palavras em uma base de dados,
conhecida na literatura como base de índices, que este módulo gerencia. Já o terceiro,
denominado por Módulo de Consulta, tem por objetivo permitir que o usuário realize
consultas, sendo que estas serão aplicadas sobre a base gerada pelo Módulo Indexador.
No entanto, conforme SALTON & MCGILL (1983) apresenta, a precisão e rapidez
de um SRI Web são medidas importantes e que devem ser levadas em consideração nos
Módulos de Indexação e Consulta. Isto porque, se a indexação do documento for feita da
11
maneira correta, a recuperação através do Módulo de Consulta será mais rápida e eficiente,
retornando documentos realmente relevantes para o usuário.
O objetivo deste trabalho é desenvolver um Módulo Indexador, que é parte de um
SRI Web, tendo como finalidade desenvolver uma estrutura de indexação de documentos
Web. Para isso, foram estudadas diversas formas de indexação, os quais serão apresentados
nas seções seguintes.
O presente trabalho está assim distribuído: a seção 2, referente a Revisão de
Literatura, aborda os conceitos necessários para o bom entendimento e conclusão deste
trabalho; a seção 3, traz os Materiais e Método utilizados para o desenvolvimento; a seção
4, apresenta os Resultados e Discussão, apresentando o Módulo de Indexação
desenvolvido; e, por fim, a seção 5 trata das Considerações Finais referentes a este
trabalho.
2. REVISÃO DE LITERATURA
Para que o objetivo deste trabalho seja alcançado, faz-se necessário que alguns
conceitos envolvidos sejam apresentados e aprofundados. Para que o Módulo de Indexação
possa ser desenvolvido é necessário ter o conhecimento de como um Sistema de
Recuperação de Informação Web está organizado, e onde e com quem este módulo se
relaciona. Por isto, esta seção inicia com o conceito de Recuperação de Informação e sobre
a necessidade dos Sistemas de Recuperação de Informação (SRI) no processo de
desenvolvimento da Web. Após estas definições, a arquitetura geral de um SRI Web é
apresentada, sendo nela contextualizado o foco deste trabalho, ou seja, o Módulo de
Indexação. Também serão apresentados alguns trabalhos correlatos, estudados e
analisados, que serviram de base para a correta conclusão deste trabalho.
2.1 Recuperando informações
DRETSKE(1981) afirma que a informação é o conhecimento sobre uma fonte, onde
a fonte é representada pelo documento original, a qual é transmitida ao receptor, sendo este
o observador da fonte.
O conceito de Recuperação de Informação, definido inicialmente em 1951 por
MOEERS (1951), avalia a recuperação de informação como sendo um processo ou método
onde o usuário converte a sua necessidade de informação numa lista real de documentos
que contenham informações relevantes para este. Afirma ainda que, a Recuperação de
Informação abrange os aspectos intelectuais da descrição da informação, a sua
especificação para a busca, assim como a utilização de sistemas ou máquinas utilizados na
recuperação da informação.
13
Estando o usuário de um Sistema de Recuperação de Informações interessado em
recuperar alguma informação sobre determinado assunto, para este a Recuperação de
Informação consiste na identificação, em um conjunto de documentos armazenados, de
documentos relevantes à sua necessidade de informação. Contudo pode-se definir como
função do Processo de Recuperação de Informações a tarefa de conversão da necessidade
do usuário em uma lista de documentos que atendam esta necessidade, sendo que o
desempenho deste processo é medido através da similaridade entre a necessidade do
usuário e a lista de documentos.
Segundo SARACEVIC (1995), a busca em um SRI é:
Um processo de alta complexidade envolvendo numerosos fatores e variáveis
além de decisões e o entrelaçamento dos sub-processos inter-relacionados com a
busca. Uma das chaves para um dos sub-processos é a da seleção dos termos para
a estratégia de busca que por sua vez é influenciada por outros fatores,
particularmente os relacionados com os resultados. Esta questão pode ser
sintetizada através da pergunta: Que
termos da busca devem ser selecionado
para um determinado tema que represente efetivamente o problema de informação
do usuário? .
Para BAEZA-YATES & RIBEIRO-NETO (1999), inicialmente, a Recuperação de
Informações era feita conforme as necessidades do usuário, ou seja, a pesquisa era feita
sobre bases de dados sem nenhuma estrutura ou organização. Neste caso, o texto era
tratado de forma natural, não considerando as ambigüidades semânticas, ou melhor, as
similaridades nos significados existentes na linguagem padrão. Muitos avanços foram
obtidos através dos diversos estudos na área de Recuperação de Informação. No entanto,
um dos maiores desafios nesta área ainda continua sendo a de definir meios para que as
informações recuperadas tenham o maior grau de relevância e aproveitamento possível,
atendendo assim as necessidades dos usuários.
Segundo SOERGEL(1985), o desempenho do Processo de Recuperação depende
principalmente da similaridade entre os termos de indexação de um documento e as
exigências da pergunta e da adaptação da pergunta às características do Processo de
Recuperação.
2.2 Recuperação de Informações na Web
14
Diversos estudos para o desenvolvimento de Sistemas capazes de compartilhar e
recuperar Informações na rede vêm sendo projetados desde 1969, quando o DOD
(Departamento de Defesa dos Estados Unidos) desenvolveu o sistema de comunicação que
permitia a interligação de computadores.
A partir do sistema de comunicação, diversas foram as redes desenvolvidas por
instituições de pesquisa e empresas privadas, criando assim uma comunidade que trocava
informações entre si. Em 1980, foi adotado como protocolo de comunicação entre redes, o
TCP/IP, formando assim uma rede de redes, também conhecida como Internet, permitindo
a troca de informações por milhares de usuários.
Em 1992 foram desenvolvidos os sistemas ARCHIE e GOPHER, sendo o
primeiro um sistema de busca em arquivos e o segundo um sistema de busca que utiliza
menus e diretórios.
Em 1989 começou a ser desenvolvida uma tecnologia com o objetivo de
compartilhar informações. Neste período as informações compartilhadas resumiam-se
apenas em documentos textuais e este compartilhamento de informações foi chamado de
Internet. Surgiu então a linguagem HTML, linguagem específica para Web juntamente
com os protocolos de comunicação denominado TCP/IP. A Web é considerada a maior
fonte de informação nas principais áreas do conhecimento, sendo formada por um conjunto
de documentos denominados páginas. Cada página disponibilizada na Internet possui seu
endereço, também chamado de URL, protocolo de transferência HTTP e a especificação
padrão para sua estrutura. A estrutura de uma página é definida pela linguagem de
marcação HTML, sendo que através desta definem-se os diferentes componentes utilizados
em uma página.
Com o advento da Web e com a facilidade de geração e disponibilização de
documentos, a Internet vem se tornando a maior fonte de armazenamento de dados, tendo
aumentado consideravelmente a quantidade de informações por esta disponibilizadas. Em
conseqüência disto, começaram a ser desenvolvidos Sistemas para Recuperação de
Informações Web que tem como objetivo a Recuperação de Informações baseada nas
necessidades de informação do usuário.
No contexto Web, a Recuperação de Informação consiste principalmente em
determinar quais documentos pertencentes a uma coleção, contém as palavras-chaves
provenientes de uma consulta de usuário. Porém, estes documentos recuperados,
15
freqüentemente, não são suficientes para satisfazer a necessidade de informação destes
usuários (BAEZA-YATES & RIBEIRO-NETO, 1999).
2.3 Sistemas de Recuperação de Informações na Web
Com o crescimento do volume de documentos disponibilizados para os usuários
através da rede mundial de computadores e devido a enorme diversidade de conteúdos
encontrado nos mesmos, tornou-se necessário o desenvolvimento de Sistemas de
Recuperação de Informações Web. Uma das maiores dificuldades encontradas por estes
sistemas referem-se à questão da recuperação rápida e precisa de documentos relevantes às
necessidades do usuário.
O problema da Recuperação de Informação Web, devido a grande quantidade de
informações que esta disponibiliza, pode ser caracterizado da seguinte forma: de que
maneira distinguir uma informação relevante que atende alguma necessidade de uma
informação irrelevante . Os sistemas automáticos cuja finalidade é resolver o problema da
Recuperação de Informação são chamados de Sistemas de Recuperação de Informações
Web (LALMAS & RIJSBERGEN, 1996).
Um Sistema de Recuperação de Informações Web (SRI Web) tem como tarefa
armazenar, manter e recuperar informações sendo estas estruturadas ou não. Seu objetivo
principal é fornecer os meios que permita diminuir o esforço humano na busca de
informações, recuperando informações que realmente atendam as necessidades dos
usuários.
É comum observar a existência de SRI relativos à áreas específicas, tal como a área
médica, a área jurídica, sistemas de bibliotecas digitais, entre outros. Porém existem outros
que trabalham com a recuperação de informação genérica. Como exemplos destes últimos
podem ser citados: Miner1, Google2, AltaVista3, entre outros tantos disponíveis na Internet.
1
Endereço: www.miner.uol.com.br
Endereço: www.google.com.br
3
Endereço: www.altavista.digital.com
2
16
A arquitetura padrão de um SRI Web é apresentado na Figura 1. Esta arquitetura
caracteriza-se por ser composta por três módulos: Controle de Robots, Módulo Indexador e
o Processo de Consulta.
Os documentos são obtidos pelo Módulo Controle de Robots, sendo que este
percorre a internet localizando novos documentos através da análise inicial de um conjunto
de documentos. Ao localizar novos documentos, estes são armazenados em um repositório
de documentos, também chamado de repositório de páginas. Após o armazenamento é
finalizada a tarefa deste módulo. A Figura 1 apresenta detalhadamente a arquitetura de um
SRI.
17
Documentos
Necessidade do usuário
Perda
de
Informação
Processo
de
Processo
de
especificação
indexação
de consulta
Uma representação dos
Índices
documentos
Processo
Consulta
de
recuperação
Lista de documentos
recuperados
Figura 1: Arquitetura Padrão SRI Web [NOGUEIRA, 1997]
O segundo, Módulo Indexador, tem como finalidade analisar cada documento
(página) encontrado no repositório de documentos. Este módulo caracteriza-se por extrair
de cada documento, as palavras-chave, assim como outras informações relevantes sobre
18
estes, armazenando-as em uma base de dados, conhecida na literatura como base de
índices.
O Módulo de Consulta permite ao usuário realizar consultas, através de uma
interface disponibilizada ao mesmo. Esta consulta é aplicada sobre a base de índices onde
estão as informações que permitem ao Módulo de Consulta, recuperar as informações que
mais se aproximam das necessidades do usuário.
Os SRI s tiveram sua importância aumentada com o advento da Internet, sendo que,
os primeiros baseavam-se na contagem da freqüência das palavras no texto (Freqüência
Absoluta4 e Freqüência Relativa5) e na eliminação de palavras de pouca relevância ou
significância, como algumas classes pertencentes à gramática como os artigos,
preposições, entre outros. No entanto, pesquisas foram surgindo até que SALTON &
MCGILL(1983), em seu livro, descreve a aplicação do processamento da linguagem
natural e da Lógica Fuzzy na Recuperação de Informações desencadeando, assim,
pesquisas relacionadas a Inteligência Artificial (IA). Além do processamento da linguagem
natural, diversas outras áreas da IA foram e estão sendo empregadas na solução de
problemas relativos à Recuperação de Informação, tais como: Sistemas Especialistas,
Redes Neurais e Algoritmos Genéticos.
Assim, os SRI´s Web devem obter os documentos (páginas) disponíveis na Web,
através do Módulo de Controle de Robots, representar o conteúdo destes documentos,
através do Módulo de Indexação e recuperá-los e apresentá-los ao usuário, através do
Módulo de Consulta.
Segundo LALMAS & RIJSBERGEN (1996) a eficiência de um sistema de
recuperação de informações Web é necessariamente medida por dois parâmetros, sendo
estes a qualidade da abrangência e a precisão dos resultados. A qualidade da abrangência
4
Freqüência Absoluta: é o número de vezes que o valor de determinada variável é observado.
Freqüência Relativa: é o quociente entre a freqüência absoluta do valor da variável e o número total de
observações
5
19
refere-se ao poder de análise de diferentes tipos de documentos utilizando-se a mesma
estrutura de indexação. Já a precisão dos resultados muitas vezes está diretamente
relacionada com questões referentes a ambigüidades inerentes à língua padrão,
dificuldades do usuário na elaboração das consultas, diferenças entre os vocabulários do
autor do documento e do usuário do sistema de recuperação, assim como deficiências no
processo de indexação.
Este trabalho, no entanto, foca apenas o Módulo de Indexação, tendo como objetivo
criar uma estrutura que permita criar os meios para melhorar a eficiência de um SRI Web.
Esta eficiência poderá ser posteriormente observada, quando o Módulo de consulta for
implementado. Porém, este último módulo citado não será abordado neste trabalho.
Para
LALMAS & RIJSBERGEN (1996), um SRI Web para ser considerado
preciso deve recuperar apenas documentos originais relevantes que correspondem
exatamente as necessidades de informação.
Para o desenvolvimento de uma estrutura de Indexação, é necessário conhecer
detalhadamente cada componente do processo de indexação. Estes componentes serão
abordados na próxima seção.
2.3.1 O Processo de Indexação
O Processo de Indexação consiste no desenvolvimento ou especificação de
estruturas de Indexação. Atualmente, o desenvolvimento de estruturas com esta finalidade
tem como meio principal de acesso aos documentos a palavra ou termo, sendo que a partir
desta foram e estão sendo desenvolvidas diversas técnicas para a indexação cada vez mais
precisas de documentos Web.
Para SOERGEL (1985), a exatidão em um Processo de Indexação é garantida pela
ausência de erros neste processo, evitando assim um menor desempenho do Processo de
Recuperação. O Processo de Indexação é suscetível a dois tipos de erros tais como: Erro de
Omissão, neste caso uma palavra relevante não é atribuída como termo de indexação e
Erro de Co-omissão, que ocorre quando uma palavra irrelevante é atribuída no Processo de
Indexação.
A Indexação é essencialmente um processo de classificação onde é realizada uma
análise conceitual do documento ou elemento de informação. A Indexação envolve a
atribuição de elementos de informação a certas classes, onde uma classe é o conjunto de
20
todos os elementos de informação para o qual um termo de Indexação (ou palavra-chave),
em particular, tem sido atribuído. Os elementos de informação podem fazer parte de várias
classes. Algumas técnicas atribuem pesos aos termos de Indexação de um elemento de
informação de forma a refletir sua relativa relevância. Nas técnicas baseadas no modelo
estatístico, os termos de indexação são extraídos a partir de uma análise de freqüência das
palavras ou frases em cada documento e em toda a fonte de informação. Nas técnicas
lingüísticas, os termos de indexação são extraídos utilizando técnicas de processamento da
linguagem natural, por exemplo, análise morfológica, lexical, sintática e semântica.
(GIRARDI, 1995).
O Processo de Indexação pode ser feito de duas formas: manual e automático. A
Indexação Manual, é feita por profissionais relacionados a área da Indexação que
especificam os assuntos, classificando-os e indexando as páginas através desta
classificação, sendo este processo similar ao realizado em bibliotecas tradicionais. Este
Processo de Indexação é considerado eficiente e de alta precisão quando a busca do usuário
está relacionada a uma categoria existente, sendo que caso contrário o resultado não terá a
precisão esperada .A Indexação Automática é feita através da seleção de endereços URL de
páginas e pela indexação destas páginas, gerando para cada uma termos de indexação que
representem seu conteúdo. Processo de Indexação Automática é bastante utilizado, apesar
de não serem revelados os métodos adotados para a realização da Indexação, fato este que
compromete o processo de avaliação dos Sistemas de Recuperação de Informações Web
(FERNEDA, 2003).
Porém diversas são as técnicas desenvolvidas para serem utilizadas juntamente com
os processos de Indexação Automática. Uma técnica é conhecida por atribuir pesos ao
conteúdo do documento, sendo que o peso do conteúdo é medido pela tag que o delimita.
A eliminação de palavras pouco significativas, como artigos e preposições e a utilização de
algoritmos para extração de radicais(Stemming) também são bastante utilizados pelos
atuais Processos de Indexação.
O Processo de Indexação tem como finalidade a extração de palavras-chave em
documentos, com o intuito de contribuir dessa forma com o Processo de Recuperação de
Informações. São diversas as maneiras e os métodos que um Processo de Indexação pode
utilizar, sendo que alguns processos relevantes para a área de Recuperação de Informação
serão apresentados a seguir.
21
Alguns sistemas computacionais se utilizam de propriedades como o grau de
relevância de um termo para o documento, sendo esta técnica melhor explicada ao
considerar como termo de indexação uma palavra que apareça em poucos documentos
reduzindo assim número de documentos que atendam as necessidades dos usuários.
Contudo, serão apresentadas abaixo algumas estruturas de Indexação já
desenvolvidas e que serviram de alicerce para o desenvolvimento da estrutura proposta
neste trabalho.
2.3.2 Trabalhos Correlatos
2.3.2.1 System for Manipulation and Retrieval of Text (SMART)
Um projeto de grande contribuição para a área de Recuperação de Informação,
desenvolvido em 1961 por Gerald Salton denominado SMART (SALTON, 1971) tem sua
implementação baseada na utilização de vetores numéricos, sendo que cada documento é
por este representado. O valor de cada palavra ou termo deste vetor descreve a importância
do termo dentro do contexto do documento. A importância dos termos para um documento
é medida através de métodos automáticos, sendo que estes calculam o peso de cada palavra
para o documento A medida utilizada para o cálculo do peso do termo é dada pela
freqüência deste no documento e pelo número de documentos nos quais este aparece.
Assim o método utilizado para a atribuição de pesos indica como melhor termo de
indexação as palavras que apresentam maior peso, sendo que estas são as que ocorrem com
grande freqüência em poucos documentos (FERNEDA, 2003).
O sistema SMART calcula e atribui pesos não só para os termos do documento
como para a expressão de busca, onde esta também é representada por um vetor, sendo
que o usuário atribui a cada termo da expressão de busca um peso, onde este especifica a
relevância de cada termo da expressão para a necessidade do usuário. Sendo este método
considerado bastante útil quando utilizado por usuários experientes e um recurso bastante
confuso quando trata-se de usuários inexperientes.
Para a utilização do sistema SMART, é necessário antes da atribuição de pesos aos
termos de indexação dos documentos, definir quais palavras do documento serão
consideradas termos de indexação, sendo que este sistema incorpora algumas ferramentas
de análise lingüística para extração automática de termos de indexação.
22
Portanto, o Processo de Indexação do sistema SMART se dá por etapas, onde o
primeiro passo é a identificar e isolar cada palavra do texto. Após este processo, são
eliminadas palavras com grande freqüência e pouco valor semântico, também chamadas de
(stop-words), tais como: preposições, artigos, entre outras palavras de pouca relevância
para a indexação de documentos. O próximo passo consiste em extrair, do conjunto de
palavras resultantes do primeiro passo, o radical, eliminando-se os sufixos e afixos,
processo este conhecido por Stemming. Após a extração do radical, estes são incorporados
aos vetores dos documentos e a este vetor é atribuído um peso que é calculado através da
medida de obtenção de pesos descrita anteriormente. Este sistema trabalha também com a
formação de termos de indexação compostos, sendo estes formados pelo agrupamento de
palavras de baixo peso formando assim termos mais específicos( FERNEDA, 2003).
2.3.1.2
Arquivos Invertidos
Outra técnica utilizada em Processos de Indexação é a utilização de Arquivos
Invertidos, por apresentar eficiência, possuir estrutura simples e por apresentar diversas
possibilidades de compressão, reduzindo assim os custos com espaço para armazenamento.
Esta técnica se utiliza de índices, que servem para localizar determinado termo em um
documento. Para a utilização desta técnica, é necessário o auxílio de uma estrutura, ou seja,
uma lista (vocabulário) composta por todos os termos contidos no documento. É
denominado Arquivo Invertido o índice que aponta os documentos que contém as palavras
que pertencem à lista ou vocabulário. Logo, um Arquivo Invertido apresenta, para cada
termo deste vocabulário, um conjunto de documentos que contém o referido termo.
Apesar de sua estrutura e funcionamento serem relativamente simples, a utilização
desta técnica torna-se inviável pelo fato da utilização dos Arquivos Invertidos consumirem
um espaço considerável. Isto levando-se em conta a quantidade de documentos existentes
na Web, sendo que isto pode ser resolvido com a utilização de armazenamento secundário
no Processo de Indexação (SILVEIRA, 1999).
2.3.2
Módulo de Indexação
23
Em um Sistema de Recuperação de Informações, o Módulo de Indexação tem como
objetivo criar estruturas de índices para que o Módulo de Consulta possa trabalhar. Para
isto, é necessário que o mesmo consulte constantemente o repositório de documentos, que
é gerado pelo Módulo Controle de Robots, para que, cada documento encontrado neste
repositório, possa ser analisado. Esta análise é a responsável por, a partir do conteúdo de
um documento, criar as estruturas de indexação, armazenando em uma base de índices as
palavras-chave, o título, subtítulos e partes do conteúdo do documento relevantes para o
processo de consulta.
Portanto, a maneira pela qual o documento será analisado está diretamente ligada
com a estrutura de indexação utilizada pelo módulo. Os primeiros Módulos de Indexação
foram desenvolvidos retirando do documento, ou seja, de seu código fonte, as tags
html/htm, eliminando também palavras repetidas dentro do documento, e palavras sem
relevância para a recuperação.
No entanto, a função do Módulo de Indexação em um Sistema de Recuperação de
Informação é a geração de uma base de índices, sendo que esta contém o endereço do
documento, título, as palavras-chave, entre outras informações que possibilitam uma maior
precisão no Processo de Recuperação.
24
3. MATERIAIS E MÉTODOS
3.1 Materiais
As pesquisas para a realização deste trabalho foram feitas
no Laboratório
Reservado aos Alunos de Estágio e TCC, utilizando os recursos de hardware e software
disponíveis.
Hardware:
Pentium III, 750MHz, com 128 MB de memória RAM;
Softwares:
Windows 2000 Professional;
SGBD MySql;
Eclipse;
J2SDK versão 1.2;
25
3.2 Método
Foram feitos levantamentos bibliográficos sobre o Processo de Recuperação de
Informações,
Sistemas de Recuperação de Informação Web, análise e adoção de
metodologias de trabalhos já desenvolvidos.
4 RESULTADOS E DISCUSSÕES
4.1 Visão Geral da Implementação
A implementação do Módulo de Indexação proposta neste trabalho foi realizada de
maneira genérica, sendo um exemplo de generalidade a opção de modificação de Banco de
Dados utilizado, onde para isso basta somente trocar o tipo de conexão, viso que as
instruções SQL utilizadas não são específicas do SGBD adotado. Outra característica é a
opção de execução da aplicação em diversas plataformas sem a necessidade de rescrever o
código, pelo fato da aplicação ser desenvolvida em Java e esta ser multiplataforma
(Windows, Linux, etc).
Para o desenvolvimento do Módulo de Indexação, objetivo deste trabalho, foi
utilizado a Linguagem de Programação Java e seus recursos, tal como o uso de Threads
para melhorar a performance do sistema, levando em conta a grande quantidade de
documentos a serem trabalhados. O motivo pela utilização desta linguagem refere-se ao
caráter multiplataforma apresentado por esta, bem como as facilidades advindas com ela,
visto que muito das estruturas a serem usadas já estão implementadas e são passíveis de
serem utilizadas.
Para desenvolver esta estrutura, foram necessários estudos sobre processos
semelhantes disponíveis na tentativa de obter uma melhor forma de indexação,
aprimorando, desta forma, o processo de Recuperação de Informações. Por isto, o Processo
de Indexação desenvolvido foi baseado no Sistema SMART, contendo também algumas
características extraídas de outros sistemas descritos na seção de trabalhos correlatos.
Considerando a quantidade de documentos e a diversidade de estruturas destes,
este trabalho propõe a Indexação de documentos que estão armazenados em um diretório
27
específico. Os documentos devem ser arquivos com extensão html/htm e estarem bem
formados seguindo os padrões da linguagem HTML 1.0.
A implementação é dividida em módulos, cada qual com sua função, sendo que o
objetivo geral desta é a extração e armazenamento do radical assim como o
armazenamento das terminações deste. No entanto, a indexação de um documento deve
focar apenas as palavras que melhor representam o conteúdo de um determinado
documento. Assim, palavras que muito se repetem ou que não são relevantes não devem
ser indexadas. Para isso, foi utilizado um vocabulário de palavras consideradas irrelevantes
para o Processo de Indexação, tais como: artigos, preposições, além de desconsiderar
acentos, sinais, caracteres especiais e números.
4.2 Arquitetura do Sistema
A arquitetura do Sistema desenvolvido é composta por três partes distintas: o
diretório, composto por documentos Web, que é o dispositivo de entrada para o Processo
de Indexação; o processamento, parte do sistema que analisa e Indexa cada documento
encontrado no repositório; e, por fim, a base de índices que é a saída do Módulo de
Indexação, onde nesta estão armazenadas informações do documento, como seu endereço,
título e palavras-chave. A arquitetura do sistema será apresentada a seguir, através da
Figura 2.
Gera
Sistema
Consulta
Repositório de Documentos
Base de Índices
O funcionamento do sistema consiste na verificação do repositório de documentos.
Se este possuir algo, o sistema inicia seu Processo de Indexação e após a execução deste
armazena os índices gerados em uma base de índices. A seguir serão apresentados os
recursos utilizados assim como as estruturas da base de índices.
28
4.2.1
Bases de Índices
Para armazenar a estrutura de índices, gerados por este módulo, foi utilizado o
Sistema Gerenciador de Banco de Dados (SGDB) MySql. A base criada para suportar a
estrutura de índices será apresentada a seguir.
Figura 3: Estrutura do Banco, Relacionamentos e Cardinalidade
A tabela url armazena o endereço de cada página juntamente com o título desta. Na
tabela topicos, para cada url armazena-se várias tags que são consideradas importantes
para o Processo de Recuperação. Cada url armazenada pode possuir vários radicais e, cada
radical presente na tabela radicais, pode apresentar diversos sufixos, sendo estes,
armazenados na tabela sufixo.
4.2.2
Eliminação: Caracteres Especiais, Sinais de Pontuação, Palavras Irrelevantes e
Números
A eliminação de caracteres especiais juntamente com sinais de pontuação faz-se
necessária para esta aplicação como intuito de evitar que palavras com significado
idêntico, mas com grafias diferentes sejam armazenadas, causando assim redundância no
armazenamento das informações. Um exemplo de fatos como este é a ocorrência da
palavra email que também pode ser encontrada com a grafia e-mail , e assim por diante.
Ao utilizar o algoritmo de eliminação, o segundo termo terá sua grafia igual ao primeiro
através da retirada do caractere - , evitando assim o armazenamento redundante. Para a
29
eliminação dos caracteres especiais e sinais de pontuação foi feita uma pesquisa sobre
estes, sendo que a lista destes a serem eliminados estão em anexo.
Com o mesmo objetivo, ou seja, indexar somente as palavras que melhor
representam um determinado documento, outra atividade a ser trabalhada refere-se a
eliminação dos artigos, preposições, conjunções, lista de palavras que deverão ser
desconsideradas para o Processo de Indexação, restringindo bastante o número de palavras
sobre as quais serão aplicadas o algoritmo para extração do radical e dos sufixos. A lista
com as palavras a serem desconsideradas foi obtida através de pesquisas em dicionários e
gramáticas da língua portuguesa e a mesma encontra-se anexada neste trabalho.
4.2.3
Algoritmo para Extração de Radicais (Stemming)
Os algoritmos de Stemming, que realizam a extração dos radicais de palavras de um
documento, são bastante utilizados por serem algoritmos genéricos, que se preocupam em
retirar o radical das palavras. Estes algoritmos têm como propósito reduzir um conjunto de
palavras em um mesmo radical sendo este chamado de Stem. Outro objetivo deste tipo de
algoritmo é chegar a um Stem que recupere uma palavra genérica. Estes algoritmos, no
entanto, podem apresentar falhas, não conseguindo, por exemplo, extrair o radical correto.
Nesta aplicação, foi desenvolvido um algoritmo que analisa um conjunto de
palavras e através de um contador de caracteres semelhantes define o grau de similaridade
entre palavras, sendo que o maior grau é considerado o radical para o conjunto de palavras
analisadas. Este algoritmo armazena então este radical e também os sufixos ou terminações
de cada radical, tornando assim a base de índices bastante genérica, oferecendo com isso
diversas maneiras de desenvolvimento do Processo de Indexação.
4.3 Considerações sobre a Implementação
Com o objetivo de desenvolver uma estrutura de indexação e considerando que
para a realização deste processo é necessário a existência de arquivos em um diretório,
parte-se do princípio que o processo de aquisição de documentos, realizado pelo primeiro
módulo, Controle de Robots, já tenha sido executado.
30
Contudo o Processo de Indexação inicia-se com a verificação da existência ou
não de novos documentos no repositório que é gerenciado pelo módulo Controle de
Robots. Este módulo armazena os novos documentos, sendo estes, arquivos html/htm, e
também os endereços ou url de cada documento, onde estas são armazenadas em arquivos
com o mesmo nome dos arquivos htm/html exceto a extensão do arquivo.
A implementação desta aplicação se dá por módulos, dividida por funções onde
cada uma tem seu objetivo, sendo que a união de todas as funções presentes na aplicação
permite que esta atinja seu objetivo principal, gerar índices representativos para os
documentos.
O primeiro passo da implementação é a verificação da existência ou não de
documentos a serem Indexados, sendo que esta rotina é descrita a seguir:
1. Verificação da existência ou não de documentos no Repositório de
Documentos;
1.1 Caso existam documentos neste repositório o Processo de Indexação aciona
as Threads, conforme a capacidade de processamento, sendo que para cada
documento existente neste uma thread é criada.
1.2 Acionamento do Processo de Indexação pelas Threads.
1.3 Inicia-se a execução do Processo de Indexação.
2 Processo de Indexação
2.1 O Processo de Indexação inicia-se com a análise do documento através de
seu código fonte.
2.2 É extraído do arquivo o conteúdo, limpo e armazenado na base de índices.
Através do código fonte do documento são extraídas as tags consideradas
relevantes para o Processo de Recuperação de Informações. O trecho de código da
aplicação que executa a extração de tags é apresentado na Figura 4.
1
2
3
4
5
while(linha.indexOf("</html>")==-1)
&&(linha.indexOf("</HTML>")==-1));
titulo = this.BuscaTag("TITLE");
linha = this.BuscaTags("H1");
tags = linha.split(" ");
Figura 4: Recuperação das tags importantes para o processo de indexação
31
O código apresentado na Figura 4, as linhas 1 e 2 percorrem todo o código fonte do
documento até ser encontrada a tag </html>, que indica o fim do código. Na linha 3, ao
percorrer todo o documento, é extraído deste o conteúdo encontrado dentro da tag <title>.
Nas linhas 4 e 5 é feita a extração do conteúdo encontrado na tag h1, sendo que a busca e
extração das tags é realizada pelas funções BuscaTags e BuscaTag, sendo a primeira
utilizada quando for possível existir mais de uma ocorrência da mesma tag e a segunda
quando a tag só ocorre uma vez, como é o caso da tag <title> ...</title>. O código dos
respectivos métodos são apresentados nas Figuras 5 e 6.
Private String BuscaTag(String tag){
1 int inicio,fim,tamanho;
2
inicio =
texto.toString().toUpperCase().indexOf("<"+tag.toUpperCase()+">");
3
fim =
texto.toString().toUpperCase().indexOf("</"+tag.toUpperCase()+">",
inicio);
4
tamanho= tag.length()+2;
5
return(texto.toString().substring(inicio+tamanho,fim));}
Figura 5: Método BuscaTag
O método BuscaTag é utilizado para buscar tags cuja ocorrência se restringe a uma
por documento. Ao instanciar este método, deve-se informar qual tag deverá ser retornada,
sendo que esta é passada por parâmetro. Na linha 1 são declaradas as variáveis que serão
utilizadas nesta função. Na linha 2, percorre-se o documento em busca da tag,
armazenando o ponto inicial desta. Na linha 3 armazena-se o ponto final da referida tag. O
retorno desta função é executado na linha 5, sendo que este é dado pelo conteúdo
encontrado entre a ocorrência de início e fim da referida tag.
Private String BuscaTags(String tag){
1 int inicio=0,fim=0,tamanho;String retorno=" ";
2do{
3 inicio
texto.toString().toUpperCase().indexOf("<"+tag.toUpperCase()+">",f
im);
4 fim
texto.toString().toUpperCase().indexOf("</"+tag.toUpperCase()+">",
32
inicio);
5 tamanho=
tag.length()+2;
6 if(inicio>=0 && fim > 0)
7 retorno = retorno +"#" +
this.HTML2Texto(texto.substring(inicio+tamanho,fim));
8
}while(texto.toString().toUpperCase().indexOf("<"+tag.toUpperCase(
)+">",fim)>0 &&
texto.toString().toUpperCase().indexOf("</"+tag.toUpperCase()+">",
inicio)>0);
9 return(retorno);
}
Figura 6: Método BuscaTags
A função BuscaTags trabalha de maneira similar a função apresentada
anteriormente. No entanto, esta é utilizada quando a tag ocorre mais de uma vez no
documento, sendo que para capturar todas as ocorrências é utilizada uma estrutura de
repetição.
Após a extração das tags, é realizado o armazenamento destas na base de índices. O
trecho de código que executa esta operação será apresentado na Figura 7.
1 for(int i=0;i<tags.length;i++){
2 strSql = "insert into
topicos(urlid,tag,conteudo)values('"+this.URL+"','<H1>','"+tags[i]
+"')";
3 stexec.execute(strSql);
Figura 7: Inserção de Tags Na base de índices
A inserção de tags na base de índices é apresentada na Figura acima, sendo
que a linha 1 executa uma estrutura de repetição para armazenar todas as ocorrências de
uma tag na base e o armazenamento é feito com a execução da linha 3
Após a extração das tags, o documento é novamente percorrido para retirar deste
todas as tags, restando somente o documento sem nenhuma tag ou script referentes a
linguagens de programação. Neste ponto, executa-se sobre o documento, a extração dos
33
caracteres especiais, sinais de pontuação e números, juntamente com a extração de palavras
irrelevantes. Esta extração é feita baseando-se em documento contendo uma lista de
palavras irrelevantes para o Processo de Indexação e em outro documento contendo uma
lista de sinais, números e caracteres a serem extraídos do documento. O método utilizado
para extração tanto dos caracteres quanto das palavras é o mesmo, mudando somente o
arquivo de referência. O código para extração é apresentado nas Figuras 8 e 9.
Private void deleteIgnoradas() throws FileNotFoundException,
IOException{
1RandomAccessFile pont new RandomAccessFile(this.PalavrasIg,"r");
2String linha="xxxx";
3
while(linha!=null){
4
linha =pont.readLine();
5
if(linha!=null)
6
this.deleteCharacter(linha,0);
}
}
Figura 8: Método deleteIgnoradas
No método apresentado na Figura 8, a linha 1 acessa o arquivo de palavras a serem
ignoradas. Na estrutura de repetição, linha 4, a variável linha recebe, linha por linha, as
palavras a serem ignoradas do arquivo correspondente e quando chegar ao final deste
arquivo, é chamada a função deleteCharacter (linha 6 ), onde por esta são passadas o
caracter a ser excluído e uma variável inteira. Para a exclusão de caracteres, sinais e
números, o processo é o mesmo, mudando somente o arquivo de sinais a ser ignorado. O
código da função deleteCharacter (String Inicial,int x) será apresentado na Figura 9
Private void deleteCharacter(String Inicial,int x)
{
int inicio,fim; String limpo="";
1
do{
2
inicio = texto.toString().toUpperCase().indexOf("
"+Inicial.toUpperCase()+" ");
3
if(inicio>=0){
4
limpo =
texto.substring(inicio,inicio+Inicial.length()+1);
5
if (inicio>=0){
texto.delete(inicio,Inicial.length()+inicio+1);
}
}
6
}while(inicio>=0);
34
}
Figura 9: Método deleteCharacter
Após a exclusão dos caracteres especiais e das palavras a serem ignoradas, o
restante das palavras são ordenadas, sendo este processo realizado através de uma função
nativa da linguagem Java, o método Sort.
Assim, após estas verificações, o documento resultante conterá somente as palavras
consideradas Termos de Indexação onde, sobre estas, é aplicado um algoritmo para
extração de seus radicais e sufixos. O trecho de código que realiza a extração de radicais
bem como sufixos e os armazena na base de índices é apresentado na Figura 10.
Private void vrPalavraChave() throws SQLException{
Int Grau;
1 lst = new ArrayList();
2 String strSql,radicalid;
3 PreparedStatement stexec;
4 ResultSet rs;
5 int menor;
6
strSql ="Select * from urls where url='"+this.URL+"'";
7
stexec = conexao.prepareStatement(strSql);
8
9
10
11
12
13
for(int i=0;i<pchaves.length-1;i++){
Grau=0;
if(pchaves[i].length()>pchaves[i+1].length()){
menor=pchaves[i+1].length();
}else{
menor=pchaves[i].length();
}
14
for(int j=0;j<menor;j++){
15
if(pchaves[i].length()> 1 && pchaves[i+1].length()> 1
&& Grau+1<pchaves[i].length() && Grau+1<pchaves[i+1].length())
16
if (pchaves[i].charAt(j) == pchaves[i+1].charAt(j) &&
pchaves[i].substring(0,Grau+1).equalsIgnoreCase(
pchaves[i+1].substring(0,Grau+1))){
17
Grau++;
}}
18
if(pchaves[i].substring(0,Grau).equalsIgnoreCase(pchaves[i+1].subs
tring(0,Grau))&&Grau>1){
19
lst.add(pchaves[i].substring(Grau));
20
strSql ="select * from radical where urlid="+this.URL+" and
palavra='"+pchaves[i].substring(0,Grau)+"'";
21
rs = stexec.executeQuery(strSql);
22
if(!rs.first()){ strSql = "insert into
radical(urlid,palavra)VALUES('"+this.URL+"','"+pchaves[i].substrin
g(0,Grau)+"')";
35
23
stexec.execute(strSql);}
24
strSql ="select * from radical where urlid="+this.URL+" and
palavra='"+pchaves[i].substring(0,Grau)+"'";
25
rs = stexec.executeQuery(strSql);
26
rs.first();
27
radicalid = rs.getObject("id").toString();
28
strSql = "insert into
sufixo(radicalid,sufixo)values("+radicalid+",'"+pchaves[i].substri
ng(Grau,pchaves[i].length())+"')";
29
stexec.execute(strSql);
30
strSql = "insert into
sufixo(radicalid,sufixo)values("+radicalid+",'"+pchaves[i+1].subst
ring(Grau,pchaves[i+1].length())+"')";
31
stexec.execute(strSql);
}
}
}
Figura 10: Extração dos Radicais e Sufixos / Armazenamento Base de Índices
A figura acima apresenta o algoritmo utilizado para extração do radical bem como
dos sufixos e o armazenamento de ambos na base de índices. Este algoritmo trabalha com a
verificação de um conjunto de palavras semelhantes, sendo que esta semelhança é medida
pela variável grau. Esta variável determina até onde o conjunto de palavras é idêntico,
armazenando na base de índices este resultado como o radical da palavra, e o restante de
cada palavra é armazenado como sufixo.
Após a extração do radical e dos sufixos e do armazenamento destes na base de
índices, o documento é excluído do repositório de documentos.
4.4 Testes
Um Modelo Subsimbólico para Indexação de Informações Textuais
Resumo
Este documento apresenta o atual estágio de desenvolvimento da pesquisa que visa implementar e
avaliar o desempenho de um modelo subsimbólico para indexação de informações textuais
destinadas a um Sistema de Informações descentralizado para a Web. O resultado do
processamento deste modelo é a sugestão de termos que representam o conteúdo de artigos que
versam sobre Inteligência Artificial, bem como os respectivos pesos que indicam o grau de
importância de cada termo em relação ao tema discutido no texto.
Figura 11: Documento a ser Indexado
36
Esta figura apresenta o documento que será usado para teste da aplicação
desenvolvida. Este é um documento refere-se a uma página htm.
A seguir será apresentado o código fonte do mesmo.
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- saved from
url=(0077)http://www.inf.ufrgs.br/pos/SemanaAcademica/Semana99/cla
udiabr/claudiabr.html -->
<HTML><HEAD><TITLE>wei 95</TITLE>
<META http-equiv=Content-Type content="text/html; charset=isso8859-1">
<META content="MSHTML 6.00.2600.0" name=GENERATOR>
<META content="C:\Program Files\Microsoft Office\Office\html.dot"
name=Template></HEAD>
<BODY vLink=#800080 link=#0000ff><B><FONT size=4>
<P align=center>Um Modelo Subsimbólico para Indexação de
Informações Textuais</P></FONT>
<P align=justify>Resumo</P></B><I>
<P align=justify>Este documento apresenta o atual estágio de
desenvolvimento da pesquisa que visa implementar e avaliar o
desempenho de um modelo subsimbólico para indexação de informações
textuais destinadas a um Sistema de Informações descentralizado
para a Web. O resultado do processamento deste modelo é a sugestão
de termos que representam o conteúdo de artigos que versam sobre
Inteligência Artificial, bem como os respectivos pesos que indicam
o grau de importância de cada termo em relação ao tema discutido o
texto. </P></I></FONT>
</BODY></HTML>
Figura 12: Código Fonte Documento Testado
Esta figura apresenta o código fonte do documento utilizado para teste da aplicação,
sendo que esta trabalha com o código fonte dos documentos.
As tags extraídas deste documento são apresentadas na Figura 13.
Figura 13: Extração de tags
37
Figura 14: Tabela de Radicais
A figura 14 apresenta os radicais extraídos do documento apresentado na figura 11.
Já a Figura 15, apresenta os sufixos extraídos deste mesmo documento, cujos radicais são
apresentados na Figura 14.
38
Figura 15: Tabela de Sufixos
4.5 Resultados
A análise dos resultados desta aplicação é apresentada na figura 16.
39
Quantidade de Palavras no Documento
Quantidade
Radicais
88
de Quantidade
de
Sufixos
14
38
Figura 16: Resultado da Indexação
Assim, é possível observar a importância da utilização de um Processo de
Indexação para Sistemas de Recuperação de Informações Web, onde com a utilização
deste, a quantidade de tempo e processamento gastos pelo Processo de Recuperação é
consideravelmente reduzida.
4.6 Limitações
Para que o sistema desenvolvido consiga atingir por completo seus objetivos, é
necessário que os documentos a serem analisados estejam bem formados, de acordo com
os padrões html 1.0.
Outra limitação refere-se a sua abrangência. Isto porque, como o sistema de
Indexação foi desenvolvido apenas utilizando a gramática da língua portuguesa, ele não
conseguiria fornecer bons resultados caso indexasse documentos em outras línguas. Porém,
esta limitação poderia ser sanada criando listas de palavras e caracteres não indexados para
estas referidas linguagens.
5 CONSIDERAÇÕES FINAIS
Com o crescimento da utilização da Web e, consequentemente, dos Sistemas de
Recuperação de Informações, em decorrência da enorme variedade de informações
disponibilizadas pela Internet, a cada dia que passa aumentam o número de pesquisas e
propostas na tentativa de melhorar as respostas fornecidas por estes tipos de sistemas a
seus usuários.
Foram analisados para o desenvolvimento desta aplicação trabalhos já realizados e
propostas de novos meios de indexação, todos estes visando o aprimoramento no Processo
de Recuperação de Informações Web.
O sistema desenvolvido tem o intuito de acrescentar os trabalhos referentes ao
Processo de Indexação, pelo fato de que a utilização deste processo ocorre na maioria dos
SRI´s disponíveis, porém ocultados o processo de indexação, fato este que acaba impondo
barreiras na evolução de novas estruturas de indexação. Se os Processos de Indexação
fossem divulgados, necessitaria apenas o desenvolvimento de técnicas para melhorar o que
já está pronto, mas como isso não ocorre, o desenvolvimento de Processos de Indexação
tem que ser feito por completo, o que acaba gerando um atraso na evolução da área de
Recuperação de Informação.
Para o desenvolvimento desta estrutura foi feito um estudo sobre as vantagens
oferecidas pelos diversos Processos de Indexação existentes, assim como das propostas
para o desenvolvimento destas. Com isso, foi obtido um conhecimento amplo sobre as
dificuldades durante o Processo de Indexação, sendo que este influi consideravelmente
para a avaliação de desempenho de SRI,s.
41
6 TRABALHOS FUTUROS
Como trabalho futuro pode ser citado a necessidade de se fazer um gerenciamento
para melhorar este no que se refere ao controle de documentos existentes. Neste trabalho,
todos os documentos existentes estão sendo indexados, mesmo que este já tenha sido
indexado anteriormente. Isto pode se tornar um problema visto que não há a necessidade
de se re-indexar um documento que não tenha sido modificado. Desta forma, pode-se,
futuramente, criar mecanismos que impeçam este re-trabalho, economizando tempo e
processamento do Sistema de Indexação.
Outro ponto a ser trabalhado, refere-se a limitação atual da ferramenta com relação
à abrangência do processo de indexação. Para que a ferramenta possa trabalhar e indexar
qualquer tipo de documento, sem perder sua funcionalidade, é necessário estudar e montar
as listas de caracteres e de palavras que não necessitam ser indexadas nas diversas
linguagens existentes.
42
7 REFERÊNCIAS BIBLIOGRÁFICAS
BAEZA-YATES, R. e RIBEIRO-NETO, B. Modern Information Retrieval.
ACM Press, Addison Wesley, 1999.
F.I.DRETSKE. Knowledge and the Flow of Information. Basic Blackwell
Publisher, 1981.
FERNEDA, E. Recuperação de Informação: Análise sobre a contribuição da
Ciência da Computação para a Ciência da Informação. 2003. Tese de
Doutorado.
GIRARDI, R. Classification and Retrieval of Software through their
Descriptions in Natural Language. Ph.D. Dissertação, No. 2782,
Geneva, Dezembro, 1995.
MACEDO, J. Recuperação de Informação Textual Distribuída por Fontes
Autônomas com Sobreposição. Tese de Doutorado, Universidade do
Ninho, Portugal, Julho 2001.
M. LALMAS & C.J. van RIJSBERGEN. Information Retrieval and Situation
Theory, 1996.
MOOERS, C. Zatocoding applied to mechanical organization of Knowledge.
American Documentation, v.2, n.1, p. 20-32, 1951.
NOGUEIRA, P.C.O., Recuperação de Informação. Universidade Federal de
Lavras, Departamento de Ciência da Computação, 1997.
SALTON, G.; McGLL, M.J. Introduction to modern information Retrieval.
Auckland: McGraw-Hill, 1983, 448p.
43
SARACEVIC, T. Interdisciplinary nature of information science. Ciência da
Informação. V. 24, n.1. p. 31-36, 1995.
SILVEIRA, M. Recuperação Aproximada de Informação em Textos
Comprimidos e Indexados. Universidade Federal de Minas Gerais.
Departamento de Ciência da Computação, 1999.
SOERGEL, D. Organizing Information. Principle of data base and Retrieval
Systems. Orlando, FL: Academic Press, 1985.
44
8 ANEXOS
45
Lista Palavras Ignoradas
o a os as eu me mim comigo tu te ti contigo ele ela se lhe si ele consigo nós conosco vós
convosco eles elas lhes si eles consigo
você senhor senhorita Vossa Excelência Vossa
Reverendíssima Eminência Santidade Majestade Imperial Alteza meu meus minha minhas
teu teus tua tuas seu seus sua suas nosso nossos nossa nossas vosso vossos vossas este
esta isto estes estas esse essa esses essas aquele aquela aquilo aqueles aquelas algum mais
qualquer bastante menos quanto cada muito tanto certo nenhum todo tudo diferente
outro um diversos pouco vários demais qual
cada qual qualquer um tal e seja qual for
sejam quem for todo quer que uma ou outra tais tal qual quais quanto quantos quanta
quantas que cujo cujos cuja cujas onde QUANTOS QUEM QUAL sempre amanhã aqui
ali talvez quando poderá será vir ser dia enquanto com isso como portanto contudo todavia
no entanto por porque por que porquê por quê certo certa certamente brevemente sendo
dessa deste desta disto
Lista de Sinais, Caracteres e Números
"'[email protected]#$%&*( )_-+=`´¨{[ª^~}]º\|,.:;?/°0123456789
46
Código
Arquivo Testa.Java
import java.io.*;
import java.sql.SQLException;
/**
* @author Samira Feitosa
* To change this generated comment edit the template variable
"typecomment":
* Window>Preferences>Java>Templates.
* To enable and disable the creation of type comments go to
* Window>Preferences>Java>Code Generation.
*/
public class Testa {
public static void main(String[] args) {
LerArq Larq;
Thread
t;
File arq = new File("c:\\temp");
File files[];
files = arq.listFiles();
String Arquivo,urlarq;
for(int i=0;i<files.length;i++){
if (files[i].getPath().indexOf(".")>0)
if(files[i].getPath().substring(files[i].getPath().length()3,files[i].getPath().length()).equalsIgnoreCase("htm")||files[i].g
etPath().substring(files[i].getPath().length()3,files[i].getPath().length()).equalsIgnoreCase("html")){
Arquivo = files[i].getPath();
urlarq=
files[i].getPath().substring(0,files[i].getPath().indexOf("."))+".
url";
try {
Larq = new LerArq(urlarq,Arquivo)
t = new Thread(Larq);
t.start();
} catch (SQLException e) {
System.out.print(e.getMessage());
47
} catch (IllegalAccessException e) {
System.out.print(e.getMessage());
} catch (ClassNotFoundException e) {
System.out.print(e.getMessage());
} catch (InstantiationException e) {
System.out.print(e.getMessage());
} catch (IOException e) {
System.out.print(e.getMessage());
}finally{
files[i].deleteOnExit();
}
}
}
}
}
48
Arquivo LerArq.java
import java.io.*;
import java.util.*;
import java.sql.*;
/**
* @author Samira Campos Feitosa
*
* To change this generated comment edit the template variable
"typecomment":
* Window>Preferences>Java>Templates.
* To enable and disable the creation of type comments go to
* Window>Preferences>Java>Code Generation.
*/
public class LerArq implements Runnable {
private RandomAccessFile file;
private StringBuffer texto;
private String[] pchaves;
private Connection conexao;
private Driver drv;
private String URL;
private List lst;
private String pontuacaofile = "c:/temp/tcc/pontuacao.txt";
private String PalavrasIg = "c:/temp/tcc/clsgramat.txt";
private int i;
public LerArq(String Urlfile,String DadosHtml) throws
FileNotFoundException, IllegalAccessException,
ClassNotFoundException, InstantiationException, IOException,
SQLException {
RandomAccessFile furl;
file = new RandomAccessFile(DadosHtml,"r");
49
furl = new RandomAccessFile(Urlfile,"r");
texto=new StringBuffer();
drv
=
(Driver)Class.forName("org.gjt.mm.mysql.Driver").newInstance();
conexao =
DriverManager.getConnection("jdbc:mysql://localhost:3306/Bdtcc","r
oot","");
URL = furl.readLine();
furl.close();
}
public void run() {
try {
ler();
} catch (IOException e) {
e.printStackTrace();
} catch (SQLException e) {
e.printStackTrace();
}
}
public int ler() throws IOException, SQLException{
int inicio,fim;
PreparedStatement stexec;
ResultSet rs;
String linha="",titulo,textolimpo,limpo="";
String tags[];
String strSql;
do{
linha =file.readLine();
texto.append(linha);
}while((linha.indexOf("</html>")==1)&&(linha.indexOf("</HTML>")==-1));
titulo = this.BuscaTag("TITLE");
strSql ="Select * from urls where url='"+this.URL+"'";
50
stexec = conexao.prepareStatement(strSql);
rs = stexec.executeQuery();
if (!rs.first()){
strSql = "insert into urls
(url,titulo)values('"+this.URL+"','"+titulo+"')";
stexec.execute(strSql);
}else{
strSql = "update urls set titulo='"+titulo+"' where
url='"+this.URL+"'";
stexec.execute(strSql);
}
strSql ="Select * from urls where url='"+this.URL+"'";
stexec = conexao.prepareStatement(strSql);
rs = stexec.executeQuery();
rs.first();
this.URL = rs.getObject("id").toString();
strSql = "delete from topicos where urlid='"+this.URL+"'";
stexec.execute(strSql);
tags = this.BuscaTags("H1").split("#");
for(int i=0;i<tags.length-1;i++){
strSql = "insert into
topicos(urlid,tag,conteudo)values('"+this.URL+"','<H1>','"+tags[i]
+"')";
stexec.execute(strSql);
}
tags = this.BuscaTags("H2").split("#");
for(int i=0;i<tags.length-1;i++){
strSql = "insert into
topicos(urlid,tag,conteudo)values('"+this.URL+"','<H2>','"+tags[i]
+"')";
stexec.execute(strSql);
}
tags = this.BuscaTags("H3").split("#");
for(int i=0;i<tags.length-1;i++){
51
strSql = "insert into
topicos(urlid,tag,conteudo)values('"+this.URL+"','<H3>','"+tags[i]
+"')";
stexec.execute(strSql);
}
tags = this.BuscaTags("H4").split("#");
for(int i=0;i<tags.length-1;i++){
strSql = "insert into
topicos(urlid,tag,conteudo)values('"+this.URL+"','<H4>','"+tags[i]
+"')";
stexec.execute(strSql);
}
tags = this.BuscaTags("H5").split("#");
for(int i=0;i<tags.length-1;i++){
strSql = "insert into
topicos(urlid,tag,conteudo)values('"+this.URL+"','<H5>','"+tags[i]
+"')";
stexec.execute(strSql);
}
tags = this.BuscaTags("H6").split("#");
for(int i=0;i<tags.length-1;i++){
strSql = "insert into
topicos(urlid,tag,conteudo)values('"+this.URL+"','<H6>','"+tags[i]
+"')";
stexec.execute(strSql);
}
linha= this.BuscaTags("B");
tags = linha.split("#");
for(int i=0;i<tags.length-1;i++){
strSql = "insert into
topicos(urlid,tag,conteudo)values('"+this.URL+"','<B>','"+tags[i]+
"')";
stexec.execute(strSql);
}
this.deleteExpressao("<!",">");
this.deleteExpressao("<script","</script>");
this.deleteExpressao("&",";");
52
this.deletePontuacao();
this.deleteIgnoradas();
textolimpo = this.HTMLtoTexto();
pchaves = textolimpo.split(" ");
Arrays.sort(pchaves);
for(int i=1;i<pchaves.length;i++){
if(pchaves[i].equalsIgnoreCase(pchaves[i-1]) &&
(!pchaves[i].equalsIgnoreCase(""))){
pchaves[i]="";
Arrays.sort(pchaves);
i--;
}
}
strSql = "delete from radical where urlid="+this.URL;
stexec.execute(strSql);
this.vrPalavraChave();
return(0);
}
/**
* Método utilizado para a recuperação de tags que ocorrem
apenas 1 vez no documento como o título da página.
* @param tag- tag a ser recuperada
* @return conteúdo relativo a tag.
* **/
private String BuscaTag(String tag){
int inicio,fim,tamanho;
inicio =
texto.toString().toUpperCase().indexOf("<"+tag.toUpperCase()+">");
fim =
texto.toString().toUpperCase().indexOf("</"+tag.toUpperCase()+">",
inicio);
tamanho=
tag.length()+2;
return(texto.toString().substring(inicio+tamanho,fim));
}
53
/**
* Método utilizado para a recuperação de tags que ocorrem
mais 1 vez no documento como o negrito,título de capítulos .
* @param tag- tag a ser recuperada
* @return conteúdo relativo a tag.
* **/
private String BuscaTags(String tag){
int inicio=0,fim=0,tamanho;
String retorno=" ";
do{
inicio =
texto.toString().toUpperCase().indexOf("<"+tag.toUpperCase()+">",f
im);
fim =
texto.toString().toUpperCase().indexOf("</"+tag.toUpperCase()+">",
inicio);
tamanho=
tag.length()+2;
if(inicio>=0 && fim > 0)
retorno = retorno +"#" +
this.HTML2Texto(texto.substring(inicio+tamanho,fim));
}while(texto.toString().toUpperCase().indexOf("<"+tag.toUpper
Case()+">",fim)>0 &&
texto.toString().toUpperCase().indexOf("</"+tag.toUpperCase()+">",
inicio)>0);
return(retorno);
}
/**
* Metodo utilizado para apagar partes do texto
* @param tag- inicio e fim para localizacao do texto a ser
apagado
* @return
* **/
private void deleteExpressao(String Inicial,String Final){
54
int inicio,fim;
String limpo="";
do{
inicio =
texto.toString().toUpperCase().indexOf(Inicial.toUpperCase());
fim
=
texto.toString().toUpperCase().indexOf(Final.toUpperCase(),inicio)
;
if(fim>inicio && inicio>=0){
limpo = texto.substring(inicio,1+fim);
if (inicio>=0){
texto.delete(inicio,Final.length()+fim);
}
}
}while(inicio>=0);
}
/**
* metodo utilizado para apagar caracteres
* @param tag- inicio do local para apagar;
* @return .
* **/
private void deleteCharacter(String Inicial)
{
int inicio,fim;
String limpo="";
do{
inicio =
texto.toString().toUpperCase().indexOf(Inicial.toUpperCase());
if(inicio>=0){
limpo =
texto.substring(inicio,inicio+Inicial.length());
if (inicio>=0){
texto.delete(inicio,Inicial.length()+inicio);
}
}
55
}while(inicio>=0);
}
/**
* Metodo utilizado para apagar determinado caracter
* @param tag- inicio do local para apagar e o caracter a ser
apagado;
* @return .
* **/
private void deleteCharacter(String Inicial,int x)
{
int inicio,fim;
String limpo="";
do{
inicio = texto.toString().toUpperCase().indexOf("
"+Inicial.toUpperCase()+" ");
if(inicio>=0){
limpo =
texto.substring(inicio,inicio+Inicial.length()+1);
if (inicio>=0){
texto.delete(inicio,Inicial.length()+inicio+1);
}
}
}while(inicio>=0);
}
/**
* Metodo utilizado para percorrer todo texto em busca de
tags html
* @param tag- ;
* @return texto sem tag .
* **/
private String HTMLtoTexto(){
int inicio,fim;
String limpo="";
56
StringBuffer textolimpo;
fim=0;
textolimpo = texto;
do{
inicio = textolimpo.indexOf("<");
fim
= textolimpo.indexOf(">",inicio);
if(fim>0 && inicio>=0){
limpo = textolimpo.substring(inicio,1+fim);
textolimpo.delete(inicio,fim+1);
}
}while(limpo.compareToIgnoreCase("</HTML>")!=0 && fim>0 &&
inicio>=0);
return(textolimpo.toString());
}
/**
* Metodo utilizado para percorrer todo texto em busca de
determinada tags
* @param tag- tag a ser recuperado ;
* @return texto sem tag .
* **/
private String HTML2Texto(String txt){
int inicio,fim;
String limpo="";
StringBuffer texto = new StringBuffer(txt);
StringBuffer textolimpo;
fim=0;
textolimpo = texto;
do{
inicio = textolimpo.indexOf("<");
fim
= textolimpo.indexOf(">",inicio);
if(fim>0 && inicio>=0){
limpo = textolimpo.substring(inicio,1+fim);
textolimpo.delete(inicio,fim+1);
}
57
}while(limpo.compareToIgnoreCase("</HTML>")!=0 && fim>0 &&
inicio>=0);
return(textolimpo.toString());
}
/**
* metodo utilizado para apagar os sinais de pontuacao,
caracteres especiais e números definidos no arquivo
* @param tag- ;
* @return .
* **/
private void deletePontuacao() throws FileNotFoundException,
IOException{
RandomAccessFile pont = new
RandomAccessFile(this.pontuacaofile,"r");
String linha="xxxx";
while(linha!=null){
linha =pont.readLine();
if(linha!=null)
this.deleteCharacter(linha);
}
}
/**
* metodo utilizado para apagar palavras irrelevantes
definidos no arquivo
* @param tag- ;
* @return .
* **/
private void deleteIgnoradas() throws FileNotFoundException,
IOException{
58
RandomAccessFile pont = new
RandomAccessFile(this.PalavrasIg,"r");
String linha="xxxx";
while(linha!=null){
linha =pont.readLine();
if(linha!=null)
this.deleteCharacter(linha,0);
}
}
/**
* metodo utilizado para extrair o radical das palavras que
sobraram do texto
* @param tag- ;
* @return .
* **/
private void vrPalavraChave() throws SQLException{
int Grau;
lst = new ArrayList();
String strSql,radicalid;
PreparedStatement stexec;
ResultSet rs;
int menor;
strSql ="Select * from urls where url='"+this.URL+"'";
stexec = conexao.prepareStatement(strSql);
for(int i=0;i<pchaves.length-1;i++){
Grau=0;
if(pchaves[i].length()>pchaves[i+1].length()){
menor=pchaves[i+1].length();
}else{
menor=pchaves[i].length();
}
for(int j=0;j<menor;j++){
59
if(pchaves[i].length()> 1 &&
pchaves[i+1].length()> 1
&& Grau+1<pchaves[i].length() &&
Grau+1<pchaves[i+1].length())
if (pchaves[i].charAt(j) ==
pchaves[i+1].charAt(j) &&
pchaves[i].substring(0,Grau+1).equalsIgnoreCase(
pchaves[i+1].substring(0,Grau+1))){
Grau++;
}
}
if(pchaves[i].substring(0,Grau).equalsIgnoreCase(pchaves[i+1]
.substring(0,Grau))&&Grau>1){
lst.add(pchaves[i].substring(Grau));
strSql ="select * from radical where
urlid="+this.URL+" and
palavra='"+pchaves[i].substring(0,Grau)+"'";
rs = stexec.executeQuery(strSql);
if(!rs.first()){
strSql = "insert into
radical(urlid,palavra)VALUES('"+this.URL+"','"+pchaves[i].substrin
g(0,Grau)+"')";
stexec.execute(strSql);
}
strSql ="select * from radical where
urlid="+this.URL+" and
palavra='"+pchaves[i].substring(0,Grau)+"'";
rs = stexec.executeQuery(strSql);
rs.first();
radicalid = rs.getObject("id").toString();
strSql = "insert into
sufixo(radicalid,sufixo)values("+radicalid+",'"+pchaves[i].substri
ng(Grau,pchaves[i].length())+"')";
stexec.execute(strSql);
strSql = "insert into
sufixo(radicalid,sufixo)values("+radicalid+",'"+pchaves[i+1].subst
ring(Grau,pchaves[i+1].length())+"')";
60
stexec.execute(strSql);
}
}
}
}
This document was created with Win2PDF available at http://www.daneprairie.com.
The unregistered version of Win2PDF is for evaluation or non-commercial use only.

Documentos relacionados