UNIVERSIDADE REGIONAL DE...
69
UNIVERSIDADE REGIONAL DE BLUMENAU CENTRO DE CIÊNCIAS EXATAS E NATURAIS CURSO DE CIÊNCIA DA COMPUTAÇÃO – BACHARELADO PROTÓTIPO DE FERRAMENTA DE CONSULTA DE INFORMAÇÕES BASEADAS EM ONTOLOGIAS PETER ANTONY RAUSCH BLUMENAU 2012 2012/1-24
Transcript of UNIVERSIDADE REGIONAL DE...
UNIVERSIDADE REGIONAL DE BLUMENAU
CENTRO DE CIÊNCIAS EXATAS E NATURAIS
CURSO DE CIÊNCIA DA COMPUTAÇÃO – BACHARELADO
PROTÓTIPO DE FERRAMENTA DE CONSULTA DE
INFORMAÇÕES BASEADAS EM ONTOLOGIAS
PETER ANTONY RAUSCH
BLUMENAU 2012
2012/1-24
PETER ANTONY RAUSCH
PROTÓTIPO DE FERRAMENTA DE CONSULTA DE
INFORMAÇÕES BASEADAS EM ONTOLOGIAS
Trabalho de Conclusão de Curso submetido à Universidade Regional de Blumenau para a obtenção dos créditos na disciplina Trabalho de Conclusão de Curso II do curso de Ciência da Computação — Bacharelado.
Profa. Joyce Martins, Mestre - Orientadora
BLUMENAU 2012
2012/1-24
PROTÓTIPO DE FERRAMENTA DE CONSULTA DE
INFORMAÇÕES BASEADAS EM ONTOLOGIAS
Por
PETER ANTONY RAUSCH
Trabalho aprovado para obtenção dos créditos na disciplina de Trabalho de Conclusão de Curso II, pela banca examinadora formada por:
______________________________________________________ Presidente: Profa. Joyce Martins, Mestre – Orientadora, FURB
______________________________________________________ Membro: Prof. Roberto Heinzle, Doutor – FURB
______________________________________________________ Membro: Prof. Paulo Fernando da Silva, Mestre – FURB
Blumenau, 11 de julho de 2012
Dedico este trabalho à minha família, aos meus amigos e a todos que me apoiaram e me incentivaram na realização deste.
AGRADECIMENTOS
À minha família, pelo apoio e companheirismo em toda minha vida.
Aos meus amigos, pela compreensão e incentivo na minha ausência para conclusão do
trabalho.
À minha orientadora, Joyce Martins, por me apoiar e me instigar no presente trabalho.
À minha namorada Glaucia, pela paciência, compreensão e amor.
Ao meu amigo e chefe, Ricardo Voigt, por me apoiar como amigo e, principalmente,
como chefe na conclusão deste trabalho.
A habilidade de alcançar a vitória mudando e adaptando-se de acordo com o inimigo é chamada de genialidade.
Sun Tzu
RESUMO
Este trabalho apresenta a especificação e a implementação de um protótipo de ferramenta de busca de informações em uma base de dados baseada em ontologias a partir de consultas formuladas em língua portuguesa. São apresentadas linguagens de descrição e consulta para web semântica (OWL, SPARQL), a especificação da gramática usada para processar as consultas formuladas em língua portuguesa e a implementação do protótipo. O protótipo foi implementado em C# ASP.NET MVC e faz uso da tecnologia Entity Framework e a biblioteca dotNetRDF para trabalhar com as linguagens da web semântica.
Palavras-chave: Processamento de linguagem natural. Web semântica. Ontologia. OWL. SPARQL.
ABSTRACT
This paper presents the specification and implementation of a prototype tool for information searching on a database based in ontologies from queries formulated in Portuguese. There are presented the description and query languages for semantic web (OWL, SPARQL), the specification of the grammar used to process queries formulated in Portuguese and the prototype implementation. The prototype was implemented in C # and ASP.NET MVC and makes use of the Entity Framework technology and the library dotNetRDF Entity Framework to work with the languages of the semantic web.
Key-words: Natural language processing. Semantic Web. Ontology. OWL. SPARQL.
LISTA DE ILUSTRAÇÕES
Quadro 1 - Código RDF ........................................................................................................... 17
Quadro 2 - Classes essenciais do RDF-Schema ....................................................................... 17
Quadro 3 - Herança no RDF-Schema ....................................................................................... 18
Quadro 4 - Ontologia sobre animais no formato OWL ............................................................ 18
Quadro 5 - Consulta SPARQL: select-where ....................................................................... 19
Quadro 6 - Consulta SPARQL: ask-where ............................................................................. 20
Quadro 7 - Consulta SPARQL: describe ............................................................................... 20
Quadro 8 - Consulta SPARQL: FILTER-isBlank ................................................................... 20
Quadro 9 - Perguntas suportadas pela ferramenta .................................................................... 28
Quadro 10 - Tokens .................................................................................................................. 29
Quadro 11 - Gramática ............................................................................................................. 29
Quadro 12 - Tokens recuperados pelas ações semânticas ......................................................... 30
Figura 1 - Diagrama de casos de uso ........................................................................................ 31
Quadro 13 – Caso de uso: Cadastrar Ontologia .................................................................. 31
Quadro 14 – Caso de uso: Cadastrar Substantivo .............................................................. 32
Quadro 15 – Caso de uso: Buscar com Linguagem SPARQL .................................................. 32
Quadro 16 – Caso de uso: Buscar com Linguagem Natural ................................................ 32
Figura 2 - Diagrama de classes ................................................................................................. 34
Figura 3 - Diagrama de sequência: BuscaController ............................................................ 35
Figura 4 - Diagrama de sequência para perguntas diretas ........................................................ 36
Quadro 17 - Passos para realizar perguntas diretas .................................................................. 36
Figura 5 - Diagrama de sequência para perguntas "Como?" .................................................... 37
Quadro 18 - Passos para realizar perguntas "Como?" .............................................................. 37
Figura 6 - Diagrama de sequência para perguntas "Qual?", "Que?", "Em que?" ..................... 38
Quadro 19 - Passos para realizar perguntas "Qual?", "Que?", "Em que?" ............................... 38
Figura 7 - Diagrama de sequência para verificar relacionamentos entre recursos ................... 39
Quadro 20 - Passos para verificar relacionamentos entre recursos .......................................... 39
Figura 8 - Diagrama de sequência para perguntas "Qual?", "O que?", "Quem?", "Onde?" ..... 39
Quadro 21 - Passos para realizar perguntas "Qual?", "O que?", "Quem?", "Onde?" ............... 40
Quadro 22 - Entity Framework: Union e Distinct ................................................................. 41
Quadro 23 - Entity Framework: Except................................................................................... 42
Quadro 24 - Entity Framework: Intersect............................................................................. 42
Quadro 25 - Entity Framework: FindAll................................................................................. 42
Quadro 26 - Entity Framework: Exists................................................................................... 42
Quadro 27 - Entity Framework: Where..................................................................................... 42
Quadro 28 - Classe Constants ................................................................................................ 43
Quadro 29 - Construtor para serialização de exceção .............................................................. 44
Quadro 30 - Método para consulta SPARQL com uso da API dotNetRDF............................. 45
Quadro 31 - Método para consulta SPARQL com cláusula ASK .............................................. 45
Quadro 32 - Consulta em SPARQL: selecionar todos substantivos da ontologia .................... 46
Quadro 33 - Consulta em SPARQL: selecionar elementos do tipo do recurso ................... 46
Quadro 34 - Consulta em SPARQL: selecionar subclasses do recurso ............................... 46
Figura 9 - Interface do protótipo............................................................................................... 47
Figura 10 – Cadastro de ontologia ............................................................................................ 47
Figura 11 - Edição da ontologia ............................................................................................... 47
Figura 12 – Ontologias cadastradas .......................................................................................... 47
Figura 13 - Detalhes da ontologia............................................................................................. 48
Figura 14 - Exclusão de ontologia ............................................................................................ 48
Figura 15 - Substantivos cadastrados ....................................................................................... 49
Figura 16 - Substantivos cadastrados - filtro habilitado ........................................................... 49
Figura 17 - Cadastro de substantivo no singular ...................................................................... 49
Figura 18 – Cadastro de substantivo no plural ......................................................................... 49
Figura 19 - Edição de substantivo no singular ......................................................................... 49
Figura 20 - Edição de substantivo no plural ............................................................................. 49
Figura 21 – Detalhes do substantivo ........................................................................................ 50
Figura 22 - Exclusão de substantivo ......................................................................................... 50
Figura 23 - Busca em SPARQL: prefixos da ontologia ........................................................... 50
Figura 24 – Busca em SPARQL ............................................................................................... 51
Figura 25 - Resultado de busca em SPARQL .......................................................................... 51
Figura 26 – Busca em linguagem natural ................................................................................. 52
Figura 27 – Resposta para: Quais ingredientes contém batata recheada? ................................ 52
Figura 28 – Resposta para: A pizza contém tomate?................................................................ 52
Figura 29 – Resposta para: Que ingredientes uma pizza contém? ........................................... 53
Figura 30 – Resposta para: Como se explora uma vulnerabilidade? ........................................ 53
Quadro 35 - Comparativo entre ferramentas ............................................................................ 55
Figura 31 - Ontologia sobre Gestão de Segurança da Informação: classes .............................. 61
Figura 32 - Indivíduos da classe Malware e seus relacionamentos .......................................... 61
Figura 33 - Indivíduos da classe EventoNatural e seus relacionamentos ................................. 61
Figura 34 - Indivíduos da classe AtacanteInterno e seus relacionamentos .............................. 62
Figura 35 - Indivíduos da classe AtacanteExterno e seus relacionamentos ............................. 62
Figura 36 - Indivíduos da classe AmbienteFisico e seus relacionamentos............................... 62
Figura 37 - Indivíduos da classe Software e seus relacionamentos .......................................... 62
Figura 38 - Indivíduos da classe ControleFisico e seus relacionamentos ................................ 62
Figura 39 - Indivíduos da classe Hardware e seus relacionamentos ........................................ 63
Figura 40 - Indivíduos da classe InformacaoDigital e seus relacionamentos ........................... 63
Figura 41 - Indivíduos da classe InformacaoFisica e seus relacionamentos ............................ 63
Figura 42 - Indivíduos da classe ControleLogico e seus relacionamentos ............................... 63
Figura 43 - Indivíduos da classe VulnerabilidadeLogica e seus relacionamentos ................... 64
Figura 44 - Indivíduos da classe VulnerabilidadeFisica e seus relacionamentos ..................... 64
Figura 45 – Ontologia sobre Alimentos: classes ...................................................................... 65
Figura 46 – Indivíduos da classe Bebida e seus relacionamentos ............................................ 65
Figura 47 – Indivíduos da classe Suco e seus relacionamentos ............................................... 65
Figura 48 – Indivíduos da classe Salgado e seus relacionamentos .......................................... 65
Figura 49 – Indivíduos da classe Ingrediente e seus relacionamentos ..................................... 66
Figura 50 – Indivíduos da classe Doce e seus relacionamentos ............................................... 66
Figura 51 - Ontologia sobre futebol: classes ............................................................................ 67
Figura 52 – Indivíduos da classe Liga e seus relacionamentos ................................................ 67
Figura 53 – Indivíduos da classe Copa e seus relacionamentos ............................................... 67
Figura 54 – Indivíduos da classe Continente e seus relacionamentos ...................................... 67
Figura 55 – Indivíduos da classe Pais e seus relacionamentos ................................................. 68
Figura 56 – Indivíduos da classe Posicao e seus relacionamentos ........................................... 68
Figura 57 – Indivíduos da classe Time e seus relacionamentos ............................................... 68
Figura 58 – Indivíduos da classe Jogador e seus relacionamentos ........................................... 68
LISTA DE SIGLAS
AJAX – Asynchronous Javascript and XML
API – Application Programming Interface
CSS – Cascading Style Sheets
EA – Enterprise Architect
FURB – Universidade Regional de Blumenau
GALS – Gerador de Analisadores Léxico e Sintático
HTML – HyperText Markup Language
IA – Inteligência Artificial
IDE – Integrated Development Environment
MVC – Model-View-Controller
OWL – Web Ontology Language
PLN – Processamento de Linguagem Natural
RDF – Resource Description Framework
RDFS – RDF-Schema
RF – Requisito Funcional
RNF – Requisito Não-Funcional
SPARQL – Simple Protocol And Rdf Query Language
UML – Unified Modeling Language
URI – Uniform Resource Identifier
URL – Unified Resource Locator
XML – eXtensible Markup Language
W3C – World Wide Web Consortium
SUMÁRIO
1 INTRODUÇÃO .................................................................................................................. 14
1.1 OBJETIVOS DO TRABALHO ........................................................................................ 15
1.2 ESTRUTURA DO TRABALHO ...................................................................................... 15
2 FUNDAMENTAÇÃO TEÓRICA .................................................................................... 16
2.1 LINGUAGENS DE DESCRIÇÃO E CONSULTA PARA WEB SEMÂNTICA ............ 16
2.1.1 RDF ................................................................................................................................. 16
2.1.2 OWL ................................................................................................................................ 18
2.1.3 SPARQL ......................................................................................................................... 19
2.2 PROCESSAMENTO DE LINGUAGEM NATURAL ..................................................... 21
2.2.1 Análise morfológica ........................................................................................................ 21
2.2.2 Análise sintática .............................................................................................................. 21
2.2.3 Análise semântica ........................................................................................................... 22
2.2.4 Análise pragmática .......................................................................................................... 22
2.3 TRABALHOS CORRELATOS ........................................................................................ 23
2.3.1 Jena .................................................................................................................................. 23
2.3.2 Geração automática de ontologias .................................................................................. 24
2.3.3 Semantic Lattes ............................................................................................................... 24
3 DESENVOLVIMENTO DO PROTÓTIPO .................................................................... 26
3.1 REQUISITOS PRINCIPAIS DO PROTÓTIPO ............................................................... 26
3.2 ESPECIFICAÇÃO ............................................................................................................ 27
3.2.1 Perguntas suportadas ....................................................................................................... 27
3.2.2 Análise das perguntas suportadas ................................................................................... 28
3.2.3 Diagrama de casos de uso ............................................................................................... 31
3.2.4 Diagrama de classes ........................................................................................................ 33
3.2.5 Diagramas de sequência .................................................................................................. 35
3.3 IMPLEMENTAÇÃO ........................................................................................................ 40
3.3.1 Técnicas e ferramentas utilizadas.................................................................................... 40
3.3.2 Migração do código gerado pelo GALS ......................................................................... 43
3.3.3 Processamento de consultas ............................................................................................ 44
3.3.4 Operacionalidade da implementação .............................................................................. 46
3.4 RESULTADOS E DISCUSSÃO ...................................................................................... 53
4 CONCLUSÕES .................................................................................................................. 56
4.1 EXTENSÕES .................................................................................................................... 57
REFERÊNCIAS BIBLIOGRÁFICAS ................................................................................. 58
APÊNDICE A – Ontologia: gestão de segurança da informação ...................................... 61
APÊNDICE B – Ontologia: Alimentos ................................................................................. 65
APÊNDICE C – Ontologia: Futebol ..................................................................................... 67
14
1 INTRODUÇÃO
Em 1989 Berners-Lee inventou a World Wide Web e em 1990 já estavam criados o
primeiro servidor e o primeiro navegador, que utilizavam a linguagem HyperText Markup
Language (HTML) como padrão. Em outubro de 1994, Berners-Lee fundou o World Wide
Web Consortium (W3C) no Laboratório de Ciência da Computação do Instituto de Tecnologia
de Massachusetts. Hoje, o W3C é responsável por ditar os padrões da web (JACOBS, 2008).
Desde então, a web adotou vários padrões, mas a maior parte de seus recursos está em
linguagem natural, interpretada somente por seres humanos. Isso fica claro quando são
efetuadas buscas. É necessário filtrar as informações que, mesmo dentro dos critérios da
consulta, pertencem a contextos diferentes. Com a proposta de computadores poderem
interpretar e processar informações surge a web semântica (BREITMAN, 2005, p. xi).
Segundo Berners-Lee, Hendler e Lassila (2001, p. 37), a web semântica é uma
extensão da web atual, na qual é dada à informação um significado bem definido, permitindo
que computadores e pessoas trabalhem em cooperação. A web semântica irá classificar as
páginas segundo uma taxonomia de assuntos e, para sua viabilização, será necessário
combinar as próprias páginas da web com recursos que indiquem do que se tratam. Esses são
os chamados metadados1. Já a definição dos termos utilizados na descrição e na representação
de uma área de conhecimento é denominada de ontologia (W3C OWL WORKING GROUP,
2009). Segundo Gruber (1993), uma ontologia é uma especificação explícita de uma
conceituação, que são entidades existentes em alguma área de interesse e suas relações. Ou
seja, a conceituação é uma visão abstrata e simplificada do mundo que deseja-se representar,
onde o que existe é exatamente o que pode ser representado.
Assim, web semântica fornece às pessoas a capacidade de criarem repositórios de
dados na web, construírem vocabulários e escreverem regras para interoperarem com estes
dados. Tudo isso é possível com a utilização das linguagens Resource Description Framework
(RDF), Web Ontology Language (OWL) e Simple Protocol And Rdf Query Language
(SPARQL) para, respectivamente, obter dados conectados, definir vocabulários e ontologias e
consultar os dados (W3C BRASIL, 2011).
Todo o esforço para definir vocabulários e ontologias não será totalmente aplicado
enquanto os computadores não forem capazes de decifrar a linguagem natural. O
1 “Metadados são dados sobre dados. O termo se refere a qualquer dado que possa ser utilizado na ajuda da identificação e localização de recursos eletrônicos dispostos em uma rede” (BREITMAN, 2005, p. xi).
15
Processamento de Linguagem Natural (PLN) entra neste contexto. Quando for perguntado
algo, o computador precisará decifrar a semântica contida na pergunta para poder inferir a
resposta de acordo com sua base de dados.
Diante do exposto, propõe-se o desenvolvimento de um protótipo de ferramenta que
possibilite buscar informações em uma base de dados de ontologias, a partir do
processamento de consultas escritas em linguagem natural. As ontologias serão definidas
utilizando as linguagens adotadas como padrão pelo W3C.
1.1 OBJETIVOS DO TRABALHO
O objetivo deste trabalho é desenvolver um protótipo de ferramenta para extrair
informações de uma base de dados baseada em ontologias, através de consultas em linguagem
natural.
Os objetivos específicos são:
a) definir uma base de dados de um domínio específico baseado em ontologias,
fazendo uso das linguagens RDF e OWL, adotadas como padrão pela W3C;
b) processar consultas em língua portuguesa, convertendo em consultas na linguagem
SPARQL;
c) gerar como resultado links para informações obtidas como resposta às consultas.
1.2 ESTRUTURA DO TRABALHO
O trabalho está organizado em quatro capítulos: introdução, fundamentação teórica,
desenvolvimento e conclusão. O capítulo 2 apresenta os aspectos teóricos estudados para o
desenvolvimento do trabalho. São relatados temas como linguagens de descrição e consulta
para web semântica e processamento de linguagem natural. Também são relacionados alguns
trabalhos correlatos. No capítulo 3 é abordado o desenvolvimento, detalhando os requisitos, a
especificação e a implementação, além dos resultados e discussões. Por fim, no capítulo 4 são
apresentadas as conclusões, bem como sugestões para possíveis extensões.
16
2 FUNDAMENTAÇÃO TEÓRICA
As seções foram divididas de acordo com os conteúdos que foram estudados para o
desenvolvimento do protótipo. A seção 2.1 descreve as linguagens recomendadas pela W3C,
necessárias para o desenvolvimento da base de dados de ontologias. A seção 2.2 descreve
brevemente algumas etapas do processamento de linguagem natural. Na última seção são
apresentados trabalhos correlatos.
2.1 LINGUAGENS DE DESCRIÇÃO E CONSULTA PARA WEB SEMÂNTICA
Segundo Berners-Lee, Hendler e Lassila (2001, p. 36), grande parte do conteúdo da
web atual é projetada apenas para o entendimento humano, não para programas de
computador manipulá-los significativamente, pois as máquinas ainda não possuem um
método seguro para processar a semântica. De acordo com os autores, o objetivo da web
semântica é trazer estrutura para o conteúdo das páginas web, aumentando-lhes o significado
e criando um ambiente onde agentes de software possam fluir de página a página cumprindo
sofisticadas tarefas para os seus usuários. Assim, estes softwares poderão, entre outras tarefas,
buscar informações na rede, encontrando, por exemplo, horários de médicos de acordo com a
disponibilidade e a área desejadas pelo usuário. Para isso, é preciso definir vocabulários e
ontologias dos diversos domínios presentes na World Wide Web usando as linguagens RDF e
OWL.
2.1.1 RDF
RDF é um modelo padrão para intercâmbio de dados na web. Seu primeiro modelo e
especificação de sintaxe foram propostos em fevereiro de 1999 pelo W3C e, atualmente, o
RDF faz parte de um conjunto de recomendações publicado em 2004. O modelo mais simples
de representação é de um grafo dirigido rotulado, onde dois nós representam os recursos e a
aresta a propriedade que os relaciona (RDF WORKING GROUP, 2004). [RDF] é uma linguagem declarativa que fornece uma maneira padronizada de
17
utilizar o XML2 para representar metadados, no formato de sentenças sobre propriedades e relacionamentos entre itens na Web. Esses itens, chamados de recursos, podem ser virtualmente qualquer objeto (texto, figura, vídeo e outros), desde que possuam um endereço Web. [...] O RDF foi projetado de modo a representar metadados de recursos Web de maneira legível e, sobretudo, processável por máquinas. (BREITMAN, 2005, p. 20).
RDF amplia a estrutura de ligação da web utilizando Uniform Resource Identifier
(URI) para relacionar itens na forma de triplas, possuindo três princípios fundamentais:
recursos, propriedades e frases. Recursos são sobre o que se deseja falar e cada um possui um
identificador URI, que pode ser uma Unified Resource Locator (URL) ou outro tipo de
identificador. Propriedades descrevem relacionamentos entre os recursos e também são
identificadas por URIs. Frases (ou objetos) são os valores dados para as propriedades e podem
ser identificados por URIs ou strings. Como exemplo, na sentença: Peter criou o recurso
www.exemplo.com.br, tem-se o recurso www.exemplo.com.br e o objeto Peter relacionados
pela propriedade criou. No modelo RDF esta sentença é ilustrada conforme o Quadro 1. <?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:f="http://www.meudominio.com.br/vocabulario/#"> <rdf:RDF> <rdf:Description about:"http://www.exemplo.com.br"> <f:criou> Peter </f:criou> </rdf:Description> </rdf:RDF>
Quadro 1 - Código RDF
Breitman (2005, p. 51) afirma que “RDF fornece uma boa representação para o
tratamento de metadados, mas não oferece os subsídios necessários para uma linguagem de
ontologias”. Assim, surge RDF Vocabulary Description Language ou RDF-Schema (RDFS)
como uma linguagem de descrição de vocabulários, através de classes e propriedades para
recursos RDF. Classes e propriedades em um RDFS são similares ao conceito de classes e
atributos em programação orientada a objetos. No Quadro 2 estão relacionadas as classes
essenciais de RDFS.
classe descrição rdfs:Resource classe de todos os recursos rdfs:Class classe de todas as classes rdfs:Literal classe de todos os literais (cadeias de caracteres) rdfs:Property classe de todas as propriedades rdfs:Statement classe de todas as sentenças reificadas
Fonte: adaptado de Breitman (2005, p. 52). Quadro 2 - Classes essenciais do RDF-Schema
Para definir relacionamentos entre as classes tem-se, por exemplo, rdfs:subClassOf,
2 eXtensible Markup Language.
18
que define um relacionamento de herança (Quadro 3). [...] <rdfs:Class rdf:ID="animal"/> <rdfs:Class rdf:ID="cavalo"> <rdfs:subClassOf rdf:resource="#animal"/> </rdfs:Class> [...]
Fonte: Breitman (2005, p. 52). Quadro 3 - Herança no RDF-Schema
Utilizando o RDF-Schema em conjunção com o RDF, tem-se um dicionário que pode
ser lido por máquinas. Mas, ainda faltam conectivos lógicos (negação, disjunção, conjunção),
limitando seu poder de expressão (BREITMAN, 2005, p. 53).
2.1.2 OWL
OWL foi projetada de modo a atender as necessidades das aplicações para web
semântica, que podem ser resumidas em construção de ontologias, explicitação de fatos sobre
um determinado domínio e racionalização sobre ontologias e fatos. Os elementos básicos de
OWL são namespaces, cabeçalhos, classes, indivíduos, propriedades e restrições
(BREITMAN, 2005, p. 59).
OWL é construída sobre RDF e faz uso de sua sintaxe. Um arquivo OWL inicia com
cabeçalhos, seguidos da ontologia que é iniciada com o elemento owl:Ontology. Outro
recurso importante são as classes, as quais, são definidas com o elemento owl:Class
(subclasse de rdfs:Class). Através de owl:Restriction pode-se definir restrições para
propriedades. Exemplificando, em uma ontologia sobre animais, os carnívoros comem
somente outros animais e o leão é um carnívoro (Quadro 4). <?xml version="1.0"?> <rdf:RDF xmlns:owl ="http://www.w3.org/2002/07/owl#" xmlns:rdf ="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:xsd ="http://www.w3.org/2001/XLMSchema#"> <owl:Ontology rdf:about="#animais"> <rdfs:comment> Exemplo de ontologia OWL </rdfs:comment> <owl:Class rdf:ID="carnivoro"> <owl:Restriction> <owl:onProperty rdf:resource="comer"/> <owl:someValuesFrom rdf:resource="animal"/> </owl:Restriction> </owl:Class> <owl:Class rdf:ID="leao"> <rdfs:subClassOf rdf:type="carnivoro"/> </owl:Class> </owl:Ontology> </rdf:RDF>
Quadro 4 - Ontologia sobre animais no formato OWL
19
Conforme Costa e Yamate (2009, p. 30), OWL nasceu como uma linguagem tão
grande para representação de ontologias e com estruturas tão complexas que o Web Ontology
Working Group do W3C dividiu-a em três sub-linguagens: OWL-Full, OWL-DL e OWL-
Lite, cada uma com um conjunto mais restrito de instruções. Recentemente, a partir de 2009, a
W3C passou a recomendar a OWL 2, uma extensão e uma revisão da OWL. OWL 2 pode ser
utilizada em conjunto com as informações descritas em RDF e OWL. OWL 2 adiciona novas
funcionalidades em relação a OWL. Algumas são sintáticas, mas outras oferecem maior
expressividade incluindo chaves, cadeias de propriedades, tipos de dados mais ricos,
intervalos de dados, restrições de cardinalidade, entre outros (W3C OWL WORKING
GROUP, 2009).
2.1.3 SPARQL
SPARQL é uma linguagem de consulta para documentos RDF. Visto que RDF é um
formato de dados de grafo dirigido para representar as informações da web, SPARQL contém
recursos para consultar padrões de grafos do RDF, juntamente com conjunções e disjunções.
Os resultados das consultas SPARQL podem ser conjuntos de resultados ou grafos RDF
(PRUD'HOMMEAUX; SEABORNE, 2008).
As consultas SPARQL muito se parecem com consultas SQL e, conforme Costa e
Yamate (2009, p. 34), são capazes de compreender a sintaxe, o modelo de dados do RDF e a
semântica dos vocabulários do RDF-Schema e OWL. O Quadro 5 traz um exemplo de uma
consulta em SPARQL. PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX an: <http://www.exemplo.com.br/animais#> SELECT ?a ?e WHERE { ?a rdf:Class an:animal; an:carnivoro ?e. }
Quadro 5 - Consulta SPARQL: select-where
Esta consulta obtém todos os grafos com triplas que possuírem um predicado
rdf:Class relacionado ao objeto an:animal e um predicado an:carnivoro relacionado a
qualquer recurso, ou seja, serão retornados todos os animais carnívoros da base de dados.
Foram utilizados os prefixos rdf: e an: para evitar a necessidade de escrever o link inteiro
em cada item da consulta.
20
Existem consultas para verificar se determinado relacionamento é verdadeiro ou falso,
como exemplificado no Quadro 6. Mudando select por ask, obtém-se como resposta
verdadeiro ou falso. Ou seja, se existir um animal carnívoro na base de dados, a consulta
retorna verdadeiro, caso contrário, falso. PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX an: <http://www.exemplo.com.br/animais#> ASK WHERE { ?a rdf:Class an:animal; an:carnivoro ?e. }
Quadro 6 - Consulta SPARQL: ask-where
Também é possível listar todos os relacionamentos de um elemento da ontologia
usando a cláusula describe. (Quadro 7). PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX an: <http://www.exemplo.com.br/animais#> DESCRIBE an:carnívoro
Quadro 7 - Consulta SPARQL: describe
Funções lógicas podem ser aplicadas como filtro para as consultas através da cláusula
FILTER. Por exemplo, a função isBlank retorna verdadeiro se o nó do grafo for branco. Nós
brancos são utilizados para identificar conjuntos infinitos e são criados quando se definem
restrições. Pode-se criar uma restrição, que será representada por um nó branco, para a classe
an:carnivoro sobre a propriedade an:come para qualquer valor da classe an:animal. A
classe an:carnívoro, então, é definida como uma subclasse do nó em branco criado. O
Quadro 8 mostra uma consulta para descobrir quem são as subclasses de an:carnívoro,
filtrando o resultado para não recuperar os nós em brancos. PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX an: <http://www.exemplo.com.br/animais#> SELECT ?a WHERE { ?a rdfs:subClassOf an:Carnivoro. FILTER(!isBlank(?a)) }
Quadro 8 - Consulta SPARQL: FILTER-isBlank
21
2.2 PROCESSAMENTO DE LINGUAGEM NATURAL
O processamento de linguagem natural tem várias aplicações, entre elas o
reconhecimento de voz, a escrita, a produção de voz a partir de texto, a análise de texto, entre
outros. A análise de textos é considerada a área mais complexa e onde tem sua maior
aplicação. É exatamente na interpretação de textos escritos que a web semântica tem grande
interesse (SCHNEIDER, 2001).
Podem-se destacar dois processos para a análise de textos: processo tradicional e
utilização de redes neurais. A utilização de redes neurais é principalmente interessante, pois
estruturas hierárquicas gramaticais não podem ser modeladas com estados finitos. Em
contrapartida, no processo tradicional é abordada a análise dos conhecimentos morfológico,
sintático, semântico e pragmático (MÜLLER, 2003).
2.2.1 Análise morfológica
A análise morfológica identifica palavras em uma sentença com o auxílio de
delimitadores, que são a pontuação e os espaços em branco. As palavras identificadas são
então classificadas de acordo com sua categoria gramatical. Assim, a morfologia trata as
palavras quanto a sua estrutura, forma, flexão e classificação, no que se refere a cada um dos
tipos de palavras.
Um exemplo de reconhecedor morfológico utilizado é o autômato finito (OLIVEIRA,
2009). Baseia-se em regras que analisam as palavras e as classificam segundo tabelas de
afixos. Por exemplo, “bonezinho” é o diminutivo da palavra “boné”, sendo que “zinho” é um
sufixo associado a um diminutivo de substantivo. Desta forma, segundo Müeller (2003),
pode-se reconhecer palavras que não estão na forma padrão adequando-as para fase posterior.
2.2.2 Análise sintática
A análise sintática baseia-se no reconhecimento da estrutura do texto, identificando os
sintagmas presentes e organizando-os dentro de uma hierarquia (BRAVO, 2010, p. 40).
O primeiro processamento que é efetuado é a identificação das classes das palavras.
22
Müeller (2003) diz que esta classificação de palavras também é conhecida como etiquetagem
(tagging) e pode ser implementada de três formas: usando regras gramaticais, usando
estatísticas para descobrir qual a próxima classe de palavras, ou fazendo uso das duas técnicas
anteriores. Ainda assim podem ocorrer situações ambíguas, pois dependendo de onde se
encontra a palavra na sentença, esta pode assumir função, por exemplo, de advérbio ou de
substantivo. Portanto, após a etiquetagem, a verificação da construção gramatical é realizada.
Para tanto, a linguagem é modelada por gramáticas livres de contexto, que divide as frases em
árvores de sintagmas nominal e verbal. A partir daí é possível verificar se cada classe
enquadra-se em cada sintagma.
A língua portuguesa possui, segundo Gagnon (2000), quatro tipos de sintagmas: verbal
(verbo), nominal (substantivo), preposicionado (preposição) e adjetival (adjetivo).
2.2.3 Análise semântica
Segundo Schneider (2001), “a análise semântica deve determinar se o contexto está
correto ou não”.
Pode-se afirmar que a semântica ramifica-se em léxica e gramatical (OLIVEIRA,
2009). A semântica léxica considera as propriedades referentes a cada uma das palavras de
uma língua. Um dos primeiros problemas a serem considerados é o fato de algumas palavras
possuírem ambiguidade, o que acarretaria em mais de uma representação ontológica. Além da
ambiguidade léxica, tem-se a ambiguidade semântica estrutural, provida de uma ambiguidade
sintática. Por exemplo, Vieira e Lima (2001, p. 52) observam que a frase “Cachorros e gatos
felizes vivem na fazenda” possui uma ambiguidade em relação ao adjetivo “feliz”, que pode
se referir tanto aos cachorros e gatos quando somente aos gatos.
2.2.4 Análise pragmática
Segundo Menegusso (2008, p. 2), a pragmática nasce como “a ciência que estuda o
significado das palavras e dos enunciados dentro de um determinado contexto, extrapolando o
sentido literal e demonstrando o que se encontra implícito na comunicação”.
Ligações anafóricas, como “este”, “ele” e “aquele”, merecem resolução. Frases também
podem ter seu sentido semântico alterado, como em um comentário sarcástico, “Bela camisa
23
Fernandinho”, o qual terá seu sentido literal contrariado conforme o contexto (OLIVEIRA,
2009). É necessário considerar vários fatores subjetivos como o contexto, condições de
produção do discurso e a formação discursiva (GOTTSCHALG-DUQUE, 2005, p. 31).
Assim, a significação da sentença, ou seja, a interpretação do todo em relação ao contexto é
feita através da pragmática.
2.3 TRABALHOS CORRELATOS
É possível encontrar exemplos de trabalhos desenvolvidos ou em desenvolvimento nos
temas de criação de ontologias, consulta em base de dados no modelo de ontologias e
extração de ontologias em textos. Foram selecionados três: um framework open-source
denominado Jena (APACHE SOFTWARE FOUNDATION, 2011), o protótipo para geração
automática de ontologias descrito por Bravo (2010) e a ferramenta Semantic Lattes (COSTA;
YAMATE, 2009).
2.3.1 Jena
Jena é um framework Java para a construção de aplicações para web semântica. Ele
fornece um ambiente de programação para RDF, RDF-Schema e OWL. Inclui suporte a
linguagem SPARQL e um motor de inferência próprio baseado em regras (APACHE
SOFTWARE FOUNDATION, 2011).
Dentre os mais diversos projetos internos, pode-se destacar Application Programming
Interface (API) para RDF e OWL e um motor de consulta em SPARQL. O Jena faz uma
abstração dos conceitos da web semântica em classes Java. O Jena inclui diferentes outros projetos internos como o ARQ, TDB e SDB, e motores de inferência próprios e o Joseki. O ARQ é uma implementação para a linguagem de consulta SPARQL. O TDB e SDB são sistemas para persistência de banco de dados, onde o primeiro é uma implementação própria e otimizada de um banco de dados, e o segundo é uma interface para utilização de bancos de dados relacionais. O Jena inclui sua própria implementação de motores de inferência, mas possibilita, por meio de interfaces, agregar diferentes implementações de terceiros. [...] O Joseki é uma implementação do protocolo SPARQL em HTTP para a realização de consultas à base de conhecimento. (COSTA; YAMATE, 2009, p. 58).
Em resumo, Jena atua como integrador de diferentes ferramentas para o
24
desenvolvimento de aplicações de web semântica.
2.3.2 Geração automática de ontologias
O objetivo geral do trabalho elaborado foi, segundo Bravo (2010, p. 3), “descrever um
processo que fosse capaz de gerar, automaticamente, ontologias a partir de conteúdo, em
língua portuguesa, disponível na web dentro de páginas elaboradas com HyperText Markup
Language (HTML)”.
O processo baseia-se na análise sintática de textos escritos em língua portuguesa para
produção de artefatos que possam ser aproveitados em aplicações para web semântica. É
preservada a estrutura sintática dos textos originais, através da representação de elementos
considerados estruturais ou de ligação. Ao final, a geração de ontologias implementa a
combinação das informações obtidas a partir da estrutura dos textos de entrada com
ontologias pré-existentes. Esta combinação favorece, segundo Bravo (2010, p. 74), a
interoperabilidade semântica e o reuso destas ontologias, o que pode ser útil na construção de
bases de conhecimento.
2.3.3 Semantic Lattes
O objetivo dos autores foi melhorar a busca de informações em currículos acadêmicos,
utilizando uma ontologia para o domínio de currículos Lattes (COSTA; YAMATE, 2009, p.
18). O projeto elabora um sistema mais intuitivo, capaz de realizar consultas sobre currículos
Lattes através de perguntas específicas como: “Quais são os professores do Departamento de
Engenharia de Computação da EPUSP?”.
Neste contexto foi desenvolvida uma ferramenta que auxilia e agiliza o processo de
consulta de informações dos currículos disponibilizados na base Lattes. Foram criadas
ontologias que foram utilizadas como base de dados ao invés dos tradicionais bancos de dados
relacionais.
O sistema desenvolvido além de realizar consultas dos principais tipos de publicações
de autores e atividades acadêmicas, também fornece a importação de novos currículos,
incorporando novos dados ou agregando mais conhecimento aos já existentes, aumentando a
base de dados. Conclui que, com o uso de ontologias, pode-se relacionar elementos de
25
diferentes domínios entre si, aumentando o conhecimento e possibilitando consultas mais
complexas.
26
3 DESENVOLVIMENTO DO PROTÓTIPO
Este capítulo apresenta as etapas do desenvolvimento do protótipo e sua utilização,
sendo que nas seções seguintes tem-se:
a) a especificação dos Requisitos Funcionais (RF) e dos Requisitos Não-Funcionais
(RNF);
b) a relação das perguntas suportadas pela ferramenta e a gramática especificada para
reconhecê-las;
c) os diagramas de casos de uso, de classes e de sequência;
d) a implementação da gramática e do processamento de consultas, incluindo as
consultas em linguagem SPARQL.
Também são detalhadas técnicas e ferramentas utilizadas na implementação, a
operacionalidade, assim como dificuldades encontradas e resultados obtidos.
3.1 REQUISITOS PRINCIPAIS DO PROTÓTIPO
O protótipo da ferramenta proposta deverá:
a) permitir cadastrar ontologias no formato OWL (RF);
b) permitir o download da ontologia cadastrada (RF);
c) permitir cadastrar substantivos (RF);
d) importar substantivos a partir de uma ontologia cadastrada (RF);
e) pluralizar os substantivos importados (RF);
f) cadastrar substantivos pluralizados (RF);
g) disponibilizar uma interface para entrada de consultas em SPARQL (RF);
h) disponibilizar o resultado de consultas SPARQL (RF);
i) disponibilizar uma interface para entrada de consultas em língua portuguesa (RF);
j) converter as consultas em língua portuguesa para consultas SPARQL (RF);
k) disponibilizar o resultado de consultas em língua portuguesa (RF);
l) ter uma base de dados baseada em ontologias (RNF);
m) ser implementada em C# e ASP.NET, utilizando o ambiente de desenvolvimento
Microsoft Visual Studio 2010 (RNF);
27
n) ser implementada seguindo o padrão Model-View-Controller (MVC) (RNF);
o) utilizar HTML5 para camada de visão (RNF);
p) utilizar o banco de dados SQL Server para armazenamento de dados (RNF);
q) ser compatível com os navegadores Internet Explorer 9 ou superior, Firefox 4 ou
superior, Google Chrome 19 ou superior, Opera 11 ou superior (RNF).
3.2 ESPECIFICAÇÃO
Nesta seção é apresentada a especificação do protótipo. São detalhadas as perguntas
suportadas e a gramática definida para analisá-las, bem como descritos os diagramas de casos
de uso, de classes e de sequência da Unified Modeling Language (UML). A gramática foi
especificada usando o GALS (GESSER, 2003). Os diagramas de sequência foram criados a
partir do código pela ferramenta Microsoft Visual Studio 2010. Os demais diagramas foram
especificados utilizando a ferramenta Enterprise Architect (EA).
3.2.1 Perguntas suportadas
O conjunto de perguntas suportado permite o usuário validar a veracidade de um
relacionamento, obter respostas quanto aos relacionamentos ou verificar cadastros da
ontologia. Para o desenvolvimento da ferramenta e testes das perguntas foram usadas três
ontologias, uma sobre gestão de segurança da informação (SILVA et al., 2011), outra sobre
alimentos e uma terceira sobre futebol, que podem ser visualizadas, respectivamente, nos
Apêndice A, Apêndice B e Apêndice C. As perguntas suportadas estão relacionadas no
Quadro 9 incluindo uma descrição da consulta a ser realizada e exemplos.
28
pergunta descrição / exemplo Quais recursos cadastrados?
− verifica quais recursos do tipo informado estão cadastrados na ontologia, retornando-os
exemplo: Quais vulnerabilidades cadastradas? O recurso é um objeto?
− verifica se há um relacionamento entre o recurso e o objeto através dos predicados owl:typeOf e rdfs:subClassOf da ontologia, retornando Verdadeiro ou Falso
exemplo: O atacante externo é uma ameaça? O recurso propriedade objeto?
− verifica se existe relacionamento entre o recurso e objeto a partir da propriedade, retornando Verdadeiro ou Falso.
exemplo: A vulnerabilidade é explorada pelo concorrente? Quais objeto propriedade recurso?
− verifica os relacionamentos com o recurso e a propriedade e filtra os itens que são do tipo ou subclasse de objeto, retornando-os
exemplo: Quais vulnerabilidades estão contidas no software ERP? Que objeto recurso propriedade?
− verifica os relacionamentos do recurso com a propriedade e filtra os itens que são do tipo ou subclasse de objeto, retornando-os
exemplo: Que vulnerabilidades o concorrente explora? O que propriedade recurso?
− verifica os relacionamentos entre o recurso e a propriedade, retornando-os
exemplo: O que está localizado no servidor de arquivos? Em que objeto propriedade recurso?
− verifica os relacionamentos entre o recurso e a propriedade e filtra os itens que são do tipo ou subclasse de objeto, retornando-os
exemplo: Em que posição joga o Messi? Como propriedade recurso?
− verifica os relacionamentos entre o recurso e a propriedade, retornando todas as triplas no formato recurso-propriedade-objeto
exemplo: Como é explorada a vulnerabilidade? Quem propriedade recurso?
− verifica os relacionamentos entre o recurso e a propriedade, retornando-os
exemplo: Quem mitiga uma vulnerabilidade física? Onde propriedade recurso?
− verifica os relacionamentos entre o recurso e a propriedade, retornando-os
exemplo: Onde está localizada a folha de pagamento? Quadro 9 - Perguntas suportadas pela ferramenta
3.2.2 Análise das perguntas suportadas
A análise das perguntas suportadas é feita usando analisadores léxico, sintático e
29
semântico3. Para tanto, fez-se necessário especificar uma gramática. A gramática especificada
identifica em perguntas diretas qual o sujeito, o verbo e o objeto da oração. Estas informações
são associadas, respectivamente, ao recurso, à propriedade e ao objeto de uma ontologia. Os
tokens foram definidos baseando-se nas classes gramaticais da língua portuguesa (Quadro 10),
adaptadas às especificidades do protótipo. A gramática encontra-se especificada no Quadro
11.
token descrição pontuação representa os símbolos de pontuação Numeral representa os numerais artigo_preposicionado representa as preposições que sofrem contração com artigos Artigo representa os artigos definidos e indefinidos preposição representa as preposições pronome representa os pronomes interrogativos pronome_qual_verbo token criado para representar “Qual é” e “Quais são” pronome_que token criado para representar “Que” no início das perguntas adverbio representa os advérbios interrogativos
negação representa as palavras “não” e “nunca” precedidas ou não pelas palavras “que”, “se” e “quando”
locucao_verbal representa um verbo auxiliar (ter, haver, ser, estar) ou as palavras “que”, “se” e “quando”, seguidos de outra palavra
verbo
representa os verbos auxiliares, bem como os regulares, que são formados por um radical acrescido de uma terminação no presente do modo indicativo, no modo infinitivo pessoal ou, no gerúndio ou particípio da forma nominal
substantivo representa os substantivos e qualquer outra palavra não identificada nas classes anteriores
Quadro 10 - Tokens
1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19 20 21
<frase> ::= <sujeito> <negacao> <verbo> <objeto> pontuacao | <sujeito_> <ligacao> <objeto_> <negacao> <verbo___> pontuacao <negacao> ::= ε | negacao #6 // *************** // ** Sujeito ** // *************** <sujeito> ::= <pre_sujeito> <nucleo> <pos_sujeito> | adverbio #5 <pre_sujeito> ::= ε | pronome #1 <pre_sujeito_> | artigo <pre_sujeito_> ::= ε | artigo <nucleo> ::= substantivo #2 <pos_sujeito> ::= ε | preposicao #3 <nucleo> <pos_sujeito> | artigo_preposicionado #4 <nucleo> <pos_sujeito> | artigo <nucleo> <pos_sujeito>
Quadro 11 - Gramática 3 O analisador léxico, também conhecido como scanner, lê o texto de entrada e o divide em tokens, que são os símbolos básicos de uma linguagem; o analisador sintático, também conhecido como parser, agrupa os tokens de acordo com a estrutura sintática da linguagem definida; e o analisador semântico extrai do programa fonte as informações que possibilitam a geração de código (GESSER, 2003, p. 10-11).
30
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
| <nucleo> <pos_sujeito> // *************** // ** Verbo ** // *************** <verbo> ::= locucao_verbal #7 <verbo_> | verbo #8 <verbo__> <verbo_> ::= ε | verbo #9 <verbo__> ::= ε | verbo #10 | locucao_verbal #11 <verbo___> ::= ε | <verbo> // *************** // ** Objeto ** // *************** <objeto> ::= ε | <pre_objeto> #12 <nucleo> <pos_objeto> <pre_objeto> ::= ε | artigo_preposicionado | artigo | preposicao artigo <pos_objeto> ::= ε | <nucleo> <pos_objeto> | preposicao #13 <nucleo> <pos_objeto> | artigo_preposicionado #14 <nucleo> <pos_objeto> // ************************* // ** Casos Especiais ** // ** Qual é ** // ** Quais são ** // ** Que ... verbo? ** // ************************* <sujeito_> ::= pronome_qual_verbo artigo #15 <nucleo> <pos_sujeito_> #18 | pronome_que #16 <nucleo> <pos_sujeito_> #17 <pos_sujeito_> ::= ε | <nucleo> <ligacao> ::= artigo_preposicionado | preposicao artigo | artigo <objeto_> ::= <nucleo> <pos_objeto>
Quadro 11 - Gramática (continuação)
Ao especificar a gramática no GALS, foram também definidas ações semânticas, que
serão disparadas para extrair informações das estruturas sintáticas. A cada ação semântica
disparada, o token recuperado é gravado em um dicionário contendo seu valor e tipo (Quadro
12). Posteriormente, de acordo com o tipo de pergunta, o algoritmo determina quem é o
sujeito, o verbo e o objeto da oração.
ação semântica token recuperado ação
semântica token recuperado #1 pronome #10 verbo #2 substantivo #11 locucao_verbal
#3 preposição #12 ε, artigo_preposicionado ou artigo
#4 artigo_preposicionado #13 Preposição #5 adverbio #14 artigo_preposicionado #6 negacao #15 artigo #7 locucao_verbal #16 pronome_que #8 verbo #17 ε ou substantivo #9 verbo #18 ε ou substantivo
Quadro 12 - Tokens recuperados pelas ações semânticas
31
3.2.3 Diagrama de casos de uso
Os casos de uso do protótipo estão divididos em Cadastros e Manutenção e Busca
como pode ser observado na Figura 1. No grupo Cadastros e Manutenção o ator executa os
cadastros necessários, bem como os mantém para, posteriormente, executar uma busca em um
dos formatos disponíveis no grupo Busca.
Busca
Cadastros e Manutenção
UC01 - Cadastrar Ontologia
Usuário
UC02 - Cadastrar Substantiv o
UC06 - Buscar com Linguagem SPARQL
UC07 - Buscar com Linguagem Natural
UC03 - Manter Ontologia
UC05 - Manter Substantiv o
UC04 - Recuperar Arquiv o OWL
«include»
«extend»
Figura 1 - Diagrama de casos de uso
O caso de uso Cadastrar Ontologia, detalhado no Quadro 13, é a ação inicial do
usuário no software. Para que seja possível executar uma busca em um dos formatos
disponíveis é necessário primeiramente cadastrar uma ontologia.
UC01 – Cadastrar Ontologia Descrição Permite cadastrar uma ontologia. Atores Usuário Cenário principal 1. O usuário informa um nome e uma descrição para a ontologia nos
campos Nome e Descrição. 2. O usuário seleciona no campo Arquivo o arquivo da ontologia
que deverá ser importado e clica no botão Adicionar. 3. O sistema importa a ontologia e cadastra os seus substantivos.
(UC02 – Cadastrar Substantivo). Exceções No passo 2: erro ao cadastrar ontologia. Caso o arquivo não possua
extensão owl, o sistema termina a operação e apresenta uma mensagem de erro.
Pré-condições O arquivo da ontologia deve estar no formato OWL. Pós-condições Ontologia e substantivos cadastrados.
Quadro 13 – Caso de uso: Cadastrar Ontologia
Ao cadastrar uma ontologia, o sistema cadastra automaticamente todos os substantivos
encontrados. Os substantivos da ontologia devem estar no singular, pois são pluralizados e os
32
respectivos plurais também são cadastrados. Os substantivos são encontrados a partir dos
elementos owl:Class e owl:NamedIndividual da ontologia. O caso de uso Cadastrar
Substantivo pode ser visualizado no Quadro 14.
UC02 – Cadastrar Substantivo Descrição Permite cadastrar substantivo(s). Atores Usuário Cenário principal (através de Cadastrar Ontologia)
1. Ao cadastrar a ontologia, o sistema procura os substantivos referentes aos atributos owl:Class e owl:NamedIndividual.
Cenário alternativo 1. O usuário seleciona uma ontologia. 2. O usuário seleciona o tipo de substantivo (singular, plural,
invariável). 3. O usuário informa sua descrição e, no caso de substantivo no
plural, informa também a correspondência com um substantivo no singular já cadastrado.
Pré-condições A ontologia deve estar cadastrada. Pós-condições Substantivo cadastrado.
Quadro 14 – Caso de uso: Cadastrar Substantivo
Após cadastrar a ontologia e os substantivos, já é possível realizar consultas, tanto em
linguagem SPARQL, como em linguagem natural através de perguntas na língua portuguesa.
Os casos de uso Buscar com Linguagem SPARQL e Buscar com Linguagem Natural
podem ser vistos no Quadro 15 e no Quadro 16, respectivamente.
UC06 – Buscar com Linguagem SPARQL Descrição Permite consultar uma ontologia utilizando linguagem SPARQL. Atores Usuário Cenário principal 1. O usuário seleciona uma ontologia cadastrada.
2. O usuário digita uma consulta no formato SPARQL. 3. O sistema efetua a consulta e apresenta o resultado.
Exceções No passo 2: caso a consulta SPARQL seja inválida, o sistema termina a operação e apresenta uma mensagem de erro.
Pré-condições A ontologia deve estar cadastrada. Pós-condições Resultado apresentado.
Quadro 15 – Caso de uso: Buscar com Linguagem SPARQL
UC07 – Buscar com Linguagem Natural Descrição Permite consultar uma ontologia utilizando língua portuguesa. Atores Usuário Cenário principal 1. O usuário seleciona uma ontologia cadastrada.
2. O usuário digita uma pergunta em língua portuguesa de acordo com os tipos suportados (Quadro 9).
3. O sistema efetua a consulta e apresenta o resultado. Exceções No passo 2: caso a pergunta não seja suportada, o sistema termina a
operação e apresenta uma mensagem de erro. Pré-condições A ontologia e os substantivos devem estar cadastrados. Pós-condições Resultado apresentado.
Quadro 16 – Caso de uso: Buscar com Linguagem Natural
Os demais casos de uso são descritos, brevemente, a seguir:
33
a) UC03 – Manter Ontologia: permite visualizar, editar e excluir uma ontologia;
b) UC04 – Recuperar Arquivo OWL: permite realizar download do arquivo da
ontologia;
c) UC05 – Manter Substantivo: permite visualizar, editar e excluir um substantivo.
3.2.4 Diagrama de classes
A Figura 2 apresenta o diagrama de classes do protótipo. As classes
OntologiaController e SubstantivoController recebem requisições do navegador e
efetuam os cadastros e a manutenção de ontologias e substantivos, respectivamente. As
classes Ontologia e Substantivo são responsáveis pela representação dos objetos para
armazenamento dos dados. A classe Substantivo possui dois enumeradores identificando
seu tipo e terminação. Os substantivos importados no cadastro de ontologia são pluralizados
de acordo com sua terminação. A classe BuscaController recebe requisições do navegador e
efetuar as consultas, tanto em SPARQL como em linguagem natural. Quando a busca é
realizada em linguagem natural, as classes Lexico e Sintatico são instanciadas para
verificação da gramática e a classe Semantico se encarrega de realizar as consultas SPARQL
necessárias para obter a resposta mais exata possível.
As classes Constants, Token, Lexico, Sintatico e Semantico foram geradas pela
ferramenta GALS para a linguagem Java e migradas para C#. O método de identificação dos
tokens na classe Lexico necessitou de um ajuste para sempre que encontrado um verbo, seja
verificado na base de dados se este na verdade não é um substantivo. A classe Semantico
possui uma lista de ClasseGramatical responsável por guardar os valores e tipos
(TipoClasseGramatical) dos tokens retornados pela classe Sintatico. Os tokens são
passados da classe Sintatico para a classe Semantico juntamente com as ações semânticas,
representadas pelo enumerador AcaoSemantica, definidas na especificação da gramática na
ferramenta GALS. Na classe Semantico foi implementada a lógica das consultas que varia de
acordo com o tipo da pergunta (especificado no Quadro 9, representado pelo enumerador
TipoPergunta).
34
Figura 2 - Diagrama de classes
35
3.2.5 Diagramas de sequência
São apresentados os diagramas de sequência que representam o conjunto de ações
necessário para o protótipo realizar a busca em linguagem natural. A classe
BuscaController recebe uma consulta em linguagem natural. São instanciadas as classes
Lexico, Sintatico e Semantico para verificar se a sentença de entrada está correta (através
do método Parse) e, em caso positivo, realizar as consultas em SPARQL para obter o
resultado para a pergunta (através do método GetResposta). A Figura 3 ilustra a sequência
descrita.
Figura 3 - Diagrama de sequência: BuscaController
O método GetResposta é responsável por identificar o tipo de pergunta, o sujeito, o
36
verbo e o objeto da oração. Identifica também se o sujeito (de quem se deseja falar) e objeto
(o que se deseja falar) precisam ser invertidos, dependendo do tipo de pergunta e da
transitividade do verbo (uso da voz passiva). Feito isto, a partir do tipo de pergunta, é
identificado o método adequado para executar a consulta. Foram criados diagramas de
sequência para os diferentes tipos de pergunta. A Figura 4 mostra o diagrama de sequência
para perguntas diretas, tais como “A vulnerabilidade é explorada pelo concorrente?”. A
resposta para este tipo de pergunta será sempre Verdadeiro ou Falso. Já o Quadro 17
apresenta os passos seguidos para efetuar a pergunta.
Figura 4 - Diagrama de sequência para perguntas diretas
passo Descrição
1 identificar, a partir do verbo da pergunta, qual é a propriedade correspondente na ontologia, bem como o seu inverso (através da propriedade owl:InverseOf)
2
procurar, a partir do sujeito da pergunta, qual é o recurso correspondente na ontologia, verificando também suas relações superiores (através das propriedades owl:typeOf e rdfs:subClassOf) para identificar se o recurso encontrado é subclasse ou é do tipo de outro recurso
3
procurar, a partir do objeto da pergunta, qual é o objeto correspondente na ontologia, verificando também suas relações inferiores (através das propriedades owl:typeOf e rdfs:subClassOf) para identificar se o objeto encontrado possui subclasse ou alguém do seu tipo
4 realizar buscas com todas as combinações entre os recursos, os objetos e a propriedade encontrados (através da cláusula ASK da linguagem SPARQL)
5
caso alguma das buscas realizadas no passo anterior retorne Verdadeiro, a pergunta formulada tem como resposta Verdadeiro, caso contrário, a busca é refeita fazendo uso da propriedade inversa (owl:inverseOf) para averiguar a direção do relacionamento
Quadro 17 - Passos para realizar perguntas diretas
Outro tipo de pergunta tratado é o que normalmente espera como resposta alguma
37
explicação, como por exemplo, “Como é explorada a vulnerabilidade?”. Nesse caso, o
algoritmo identifica a propriedade e o objeto da oração, realizando uma busca por todas as
triplas que satisfazem a condição. As triplas que satisfazem a condição são mostradas como
resultado da consulta. A Figura 5 mostra o diagrama de sequência para este modelo de busca e
o Quadro 18 apresenta os passos seguidos.
Figura 5 - Diagrama de sequência para perguntas "Como?"
passo descrição
1 identificar, a partir do verbo da pergunta, qual é a propriedade correspondente na ontologia, bem como o seu inverso (através da propriedade owl:InverseOf)
2 procurar, a partir do objeto da pergunta, qual é o objeto correspondente na ontologia, verificando também suas relações inferiores (através das propriedades owl:typeOf e rdfs:subClassOf)
3 procurar quais os recursos da ontologia se relacionam com a propriedade e os objetos encontrados
4 procurar, a partir da lista de recursos encontrados no passo 3, suas relações superiores (através das propriedades owl:typeOf e rdfs:subClassOf)
5 realizar buscas com todas as combinações entre os recursos, os objetos e a propriedade encontrados (através da cláusula ASK da linguagem SPARQL)
6 a pergunta formulada tem como resposta as tripas que retornarem Verdadeiro no passo anterior
Quadro 18 - Passos para realizar perguntas "Como?"
Para perguntas do tipo “Quais ingredientes contém uma pizza?”, “Que campeonatos o
Santos participa?”, “Em que posição joga o Messi?”, deve-se identificar o recurso, o objeto e
a propriedade a qual se quer relacionar. Nesses casos, o protótipo relaciona primeiramente a
propriedade ao objeto da pergunta. Com isto, têm-se os possíveis recursos da ontologia dos
quais se deseja falar. O último passo é a partir do sujeito da pergunta filtrar os possíveis
recursos, validando se são de nível inferior através dos predicados owl:typeOf e
rdfs:subClassOf. A Figura 6 mostra o diagrama de sequência e o Quadro 19 os passos para
este tipo de pergunta.
38
Figura 6 - Diagrama de sequência para perguntas "Qual?", "Que?", "Em que?"
passo descrição
1 identificar, a partir do verbo da pergunta, qual é a propriedade correspondente na ontologia, bem como o seu inverso (através da propriedade owl:InverseOf)
2 procurar, a partir do sujeito da pergunta, qual é o recurso correspondente na ontologia, verificando também suas relações superiores (através das propriedades owl:typeOf e rdfs:subClassOf)
3 procurar, a partir do objeto da pergunta , qual é o objeto correspondente na ontologia, verificando também suas relações inferiores (através das propriedades owl:typeOf e rdfs:subClassOf)
4 procurar os relacionamentos existentes entre os objetos e as propriedades encontrados, montando uma lista de possíveis sujeitos de quem se deseja falar
5 filtrar a lista de possíveis sujeitos, verificando quais estão em níveis inferiores de relacionamento com relação aos sujeitos encontrados a partir do sujeito da pergunta (através das propriedades owl:typeOf e rdfs:subClassOf)
Quadro 19 - Passos para realizar perguntas "Qual?", "Que?", "Em que?"
Pode-se desejar saber se um recurso da ontologia é de determinado tipo, ou seja, se
existe um relacionamento com as propriedades owl:typeOf e rdfs:subClassOf entre dois
recursos. Para isto, têm-se perguntas como “O Messi é um jogador?”. Nesse caso, o algoritmo
verifica se o recurso “jogador” possui alguma subclasse ou algum tipo que se chama “Messi”.
Os passos gerais são apresentados e descritos, respectivamente, no diagrama de sequência da
Figura 7 e no Quadro 20.
39
Figura 7 - Diagrama de sequência para verificar relacionamentos entre recursos
passo descrição
1 identificar, a partir do sujeito da pergunta, qual é o recurso correspondente na ontologia
2 identificar, a partir do objeto da pergunta, qual é o recurso correspondente na ontologia
3 identificar se a lista associada ao sujeito encontra-se na lista associada ao objeto
4 caso a busca realizada no passo anterior retorne Verdadeiro, a pergunta formulada tem como resposta Verdadeiro, caso contrário, tem como resposta Falso
Quadro 20 - Passos para verificar relacionamentos entre recursos
O último modelo de busca é para perguntas que não se sabe exatamente qual sujeito se
espera. Nesse caso, é feito o relacionamento entre o objeto da ontologia relacionado ao objeto
da pergunta e a propriedade encontrada na ontologia a partir do verbo da pergunta. As
perguntas que se encaixam nesse contexto são “Quais vulnerabilidades cadastradas?”, “O que
está localizado no servidor de arquivos?”, “Quem participa da Libertadores?”, “Onde está
localizada a folha de pagamento?”. A Figura 8 apresenta o respectivo diagrama de sequência,
cujas etapas estão descritas no Quadro 21.
Figura 8 - Diagrama de sequência para perguntas "Qual?", "O que?", "Quem?", "Onde?"
40
passo descrição
1 identificar, a partir do verbo da pergunta, qual é a propriedade predicado correspondente na ontologia, bem como o seu inverso (através da propriedade owl:InverseOf)
2 procurar, a partir do objeto da pergunta, qual é o objeto correspondente na ontologia, verificando também suas relações inferiores (através das propriedades owl:typeOf e rdfs:subClassOf)
3 procurar os relacionamentos existentes entre os objetos e as propriedades encontrados, montando uma lista com os resultados
Quadro 21 - Passos para realizar perguntas "Qual?", "O que?", "Quem?", "Onde?"
3.3 IMPLEMENTAÇÃO
Nesta seção é apresentada a implementação do protótipo, iniciando com as técnicas, as
ferramentas e as bibliotecas utilizadas. Também é descrita a migração do código gerado pela
ferramenta GALS de Java para C#. Por fim, são apresentados o processamento das consultas e
a operacionalidade da ferramenta desenvolvida.
3.3.1 Técnicas e ferramentas utilizadas
As técnicas e ferramentas utilizadas para o desenvolvimento do protótipo proposto
foram as seguintes:
a) a ferramenta GALS (GESSER, 2003), utilizado para especificar a gramática e
gerar o código que implementa os analisadores léxico e sintático;
b) a ferramenta NeOn Toolkit (MOTTA, 2012), utilizada na construção das
ontologias;
c) a Integrated Development Environment (IDE) Microsoft Visual Studio 2010,
utilizada para a codificação do protótipo;
d) o framework ASP.NET MVC (MICROSOFT ASP.NET TEAM, 2009), usado
como base do protótipo, que foi implementado em três camadas (model, view e
control);
e) o banco de dados SQL Server juntamente com a IDE SQL Managment Studio;
f) o Entity Framework (LERMAN, 2011), utilizado para a integração entre o C# e o
banco de dados SQL Server;
41
g) as linguagens C#, ASP.NET, JavaScript, HTML5, Cascading Style Sheets (CSS);
h) a view engine Razor (MICROSOFT, 2012), usada na camada view, tornando o
código mais compacto e legível;
i) a biblioteca JavaScript jQuery (JQUERY FOUNDATION, 2012), que facilitou a
animação de formulários e o uso de requisições Asynchronous Javascript and XML
(AJAX);
j) a biblioteca dotNetRDF (VESSE, 2012), usada para consultar os arquivos OWL
com o uso da linguagem SPARQL através do C#.
As ferramentas mais relevantes são apresentadas a seguir. As ontologias utilizadas
para testar o protótipo foram construídas na ferramenta NeOn Toolkit (MOTTA, 2012), que é
um ambiente de engenharia de ontologias para modelar ontologias. É baseada no Eclipse e
permite a extensão por meio de plug-ins desenvolvidos por desenvolvedores externos ao
projeto.
O Microsoft ADO.NET Entity Framework simplifica o acesso a dados, evitando o
trabalho direto com o banco de dados no código implementado. É possível recuperar, incluir,
deletar e alterar dados escrevendo consultas com classes fortemente tipadas, deixando a
interação com o banco de dados com o Entity Framework. Assim, não é necessário escrever
código extra para especificar uniões e junções entre entidades ao expressar consultas ou
simplesmente trabalhar com objetos em memória (LERMAN, 2011). Entity Framework
oferece três maneiras de descrever o modelo de entidades:
a) iniciar com um banco de dados já existente para criar um modelo de classes;
b) criar um modelo de classes;
c) definir classes deixando a criação do banco de dados com o framework.
Visto que em muitos casos a palavra contida na pergunta não é exatamente o que está
cadastrado na ontologia, fez-se uso da teoria de conjuntos (união, intersecção, exclusão) para
se encontrar exatamente um determinado elemento. O Quadro 22 mostra um trecho de código
que exemplifica como unir duas listas (método Union), retornando os elementos sem
duplicatas (métodos Union e Distinct do Entity Framework). 1 2 3 4 5 6 7 8
/********************************************************************** * O método Union unifica duas listas. * O método Distinct remove os elementos duplicados. **********************************************************************/ List<string> superClass = GetSuperClass(possiveisSujeitos); List<string> typesOf = GetTypeOfClass(possiveisSujeitos); List<string> encontrados = superClass.Union(typesOf).Distinct().ToList();
Quadro 22 - Entity Framework: Union e Distinct
O Quadro 23 apresenta um trecho de código que mostra como excluir elementos de
42
uma lista a partir de elementos de outra lista (método Except), enquanto o Quadro 24 mostra
como realizar intersecção entre duas listas (método Intersect). 1 2 3 4 5 6
/********************************************************************** * O método Except retorna uma nova lista com os elementos da lista * “encontrados” excluídos os elementos da lista “possiveisSujeitos”. * O método Count contabiliza os elementos retornados. **********************************************************************/ if (encontrados.Except(possiveisSujeitos).ToList().Count > 0) { }
Quadro 23 - Entity Framework: Except
1 2 3 4 5
/********************************************************************** * O método Intersect (linha 25) retorna uma nova lista somente com os * elementos presentes nas duas listas (intersecção). ***********************************************************************/ resultado = listaNormal.Intersect(listaInversa).ToList();
Quadro 24 - Entity Framework: Intersect
O Quadro 25 exibe um trecho de código para recuperar todos elementos de uma lista
que atendam à determinada condição (método FindAll). O Quadro 26 expõe como saber se
um determinado elemento está contido na lista (método Exists). Por fim, o Quadro 27
apresenta como recuperar uma lista com determinadas condições (método Where). 1 2 3 4 5 6 7
/********************************************************************** * O método FindAll retorna todos os elementos da lista que atendem à * condição passada como parâmetro. ***********************************************************************/ List<ClasseGramatical> l = this.Leitura.FindAll(cg => cg.Tipo.Equals(TipoClasseGramatical.Outro) ||
cg.Tipo.Equals(TipoClasseGramatical.LocucaoVerbal));
Quadro 25 - Entity Framework: FindAll
1 2 3 4 5 6
/********************************************************************** * O método Exists retorna se existe algum elemento na lista que atende * à condição passada como parâmetro. ***********************************************************************/ this.PossuiNegacao = this.Leitura.Exists(cg => cg.Tipo.Equals(TipoClasseGramatical.Negacao));
Quadro 26 - Entity Framework: Exists
1 2 3 4
/********************************************************************** * O método Where filtra a lista com as regras passadas como parâmetro. ***********************************************************************/ return subClasses.Where(s => !string.IsNullOrWhiteSpace(s)).ToList();
Quadro 27 - Entity Framework: Where
O projeto dotNetRDF, segundo Vesse (2012), tem como objetivo criar uma biblioteca
.NET open source para fornecer uma API para facilitar o trabalho com RDF. Foi
desenvolvida para ter seu core relativamente simples, mas altamente extensível, tendo sido
criada com uma abordagem semelhante à API Jena. As classes são autoexplicativas, pois se
relacionam diretamente com os conceitos de RDF e o uso de interfaces padrão permite aos
usuários escrever código independente das implementações da biblioteca. Entre todas as
funcionalidades que dotNetRDF disponibiliza, o protótipo fez uso do suporte para consultas
SPARQL.
43
3.3.2 Migração do código gerado pelo GALS
A partir da gramática especificada para identificar as perguntas suportadas pelo
protótipo, gerou-se o código dos analisadores léxico e sintático para a linguagem Java. O
código foi convertido manualmente para C#. Pode-se notar que apesar da sintaxe das duas
linguagens serem muito semelhantes, a forma de trabalhar com exceptions e interfaces é
diferente: Java permite que uma interface possua atributos, C# não. As interfaces
geradas pelo GALS definem atributos. Assim, essas, bem como a classe que as implementa,
foram convertidas para uma mesma classe, porém definidas em arquivos distintos fazendo uso
da partial class do C#, conforme ilustrado no Quadro 28. namespace GALS.Base { public partial class Constants { protected const int START_SYMBOL = 15; protected const int FIRST_NON_TERMINAL = 15; protected const int FIRST_SEMANTIC_ACTION = 33; protected readonly int[][] PARSER_TABLE = { }; protected readonly int[][] PRODUCTIONS = { }; protected readonly string[] PARSER_ERROR = { }; } } namespace GALS.Base { public partial class Constants { protected const int EPSILON = 0; protected const int DOLLAR = 1; protected const int t_pontuacao = 2; protected const int t_numeral = 3; protected const int t_artigo_preposicionado = 4; protected const int t_artigo = 5; protected const int t_preposicao = 6; protected const int t_pronome = 7; protected const int t_pronome_qual_verbo = 8; protected const int t_pronome_que = 9; protected const int t_adverbio = 10; protected const int t_negacao = 11; protected const int t_locucao_verbal = 12; protected const int t_verbo = 13; protected const int t_substantivo = 14; public static string GetNameConstant(int index) { }; } } namespace GALS.Base { public partial class Constants { protected readonly int[] SCANNER_TABLE_INDEXES = { }; public readonly int[][] SCANNER_TABLE = { }; public readonly int[] TOKEN_STATE = { }; public readonly string[] SCANNER_ERROR = { }; } }
Quadro 28 - Classe Constants
Classes de exceção do C# devem ser serializáveis e necessitam de um construtor
especial utilizado para a serialização da exceção (Quadro 29).
44
namespace GALS.Exception { [Serializable] public class AnalysisException : System.Exception { private int _position; public int Position { get { return this._position; } } public AnalysisException(String msg, int position): base(msg) { this._position = position; } public AnalysisException(String msg): base(msg) { this._position = -1; } protected AnalysisException(SerializationInfo info, StreamingContext context) { } public override string ToString() { return base.ToString() + ", @ " + _position; } } }
Quadro 29 - Construtor para serialização de exceção
3.3.3 Processamento de consultas
Como já comentado, as consultas SPARQL através do C# foram implementadas
usando a biblioteca dotNetRDF. O Quadro 30 mostra o método utilizado para realizar uma
consulta em determinada ontologia. É necessário informar a ontologia e a query em SPARQL.
O algoritmo instancia um objeto do tipo Graph (linha 3), carrega os dados da ontologia a
partir do arquivo cadastrado na ferramenta (linha 4), monta os prefixos necessários para
realizar a consulta (linha 5), monta a query que será executada juntando os prefixos com a
query que foi passada como parâmetro (linha 6), executa a query (linha 7), retorna um objeto
do tipo SparqlResultSet contendo um dicionário com o resultado da consulta (linha 8).
Foi criado também um método exclusivo para consultas com a cláusula ASK, mostrado
no Quadro 31. Este método recebe como parâmetros a ontologia a qual se deseja pesquisar, o
recurso, a propriedade e o objeto para a validação do relacionamento. O algoritmo instancia o
objeto Graph (linha 8), carrega os dados da ontologia a partir do arquivo cadastrado na
ferramenta (linha 9), monta os prefixos necessários para realizar a consulta (linha 10), monta
a query que será executada, com os prefixos, a partir dos parâmetros (linha 11-17), executa a
query (linha 18), retorna Verdadeiro ou Falso.
45
1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
public static SparqlResultSet Select(Ontologia ontologia, string selectQuery) { using (Graph g = new Graph()) { FileLoader.Load(g, ontologia.Arquivo); string prefixos = GetPrefixos(g); string query = string.Format("{0}\r\n{1}", prefixos, selectQuery); SparqlResultSet results = g.ExecuteQuery(query) as SparqlResultSet; return results; } } private static string GetPrefixos(Graph g) { Dictionary<string, string> prefixURI = new Dictionary<string, string>(); g.NamespaceMap.Prefixes.ToList().ForEach (prefix => prefixURI.Add(prefix, g.NamespaceMap.GetNamespaceUri(prefix).AbsoluteUri));
StringBuilder prefixos = new StringBuilder(); foreach (KeyValuePair<string, string> prefixo in prefixURI) prefixos.AppendLine(string.Format("PREFIX {0}: <{1}>", string.IsNullOrWhiteSpace(prefixo.Key) ? "base" : prefixo.Key, prefixo.Value) ); return prefixos.ToString(); }
Quadro 30 - Método para consulta SPARQL com uso da API dotNetRDF
1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19 20 21 22 23
public static bool Ask(Ontologia ontologia, string sujeito, string predicado, string objeto) { if (!string.IsNullOrWhiteSpace(sujeito) && !string.IsNullOrWhiteSpace(predicado) && !string.IsNullOrWhiteSpace(objeto)) { using (Graph g = new Graph()) { FileLoader.Load(g, ontologia.Arquivo); string prefixos = GetPrefixos(g); StringBuilder queryASK = new StringBuilder(); queryASK.AppendLine("ASK"); queryASK.AppendLine("{"); queryASK.AppendLine(string.Format(" {0} {1} {2}.", sujeito, predicado, objeto)); queryASK.AppendLine("}"); string query = string.Format("{0}\r\n{1}", prefixos, queryASK); SparqlResultSet results= g.ExecuteQuery(query) as SparqlResultSet; return results.Result; } } return false; }
Quadro 31 - Método para consulta SPARQL com cláusula ASK
Já o atributo owl:Class é usado para listar todas classes e subclasses, assim como o
atributo owl:NamedIndividual é utilizado para listar os indivíduos da ontologia. Os
elementos que são classes e indivíduos da ontologia são classificados como substantivos da
ontologia. O Quadro 32 mostra a consulta SPARQL que retorna estes elementos. Para
descobrir os elementos inferiores, realiza-se consultas com as propriedades rdfs:subClassOf
e owl:typeOf (também representado por a). O Quadro 33 e o Quadro 34 mostram,
respectivamente, as consultas em SPARQL realizadas para se obter a informação dos
elementos que são do tipo do recurso, bem como suas subclasses.
46
SELECT DISTINCT ?x WHERE { { ?x a owl:Class. FILTER (!isBLANK(?x)) } UNION { ?x rdf:type owl:NamedIndividual. FILTER (!isBLANK(?x)) } }
Quadro 32 - Consulta em SPARQL: selecionar todos substantivos da ontologia
SELECT ?ehDoTipo WHERE { { recurso a ?ehDoTipo } FILTER(!isBlank(?ehDoTipo) }
Quadro 33 - Consulta em SPARQL: selecionar elementos do tipo do recurso SELECT ?filho WHERE { ?filho rdfs:subClassOf recurso. FILTER(!isBlank(?filho) }
Quadro 34 - Consulta em SPARQL: selecionar subclasses do recurso
3.3.4 Operacionalidade da implementação
A operacionalidade do protótipo, denominado OnTo Busca, é bastante simplificada.
Na Figura 9 pode ser vista a interface da ferramenta.
Para utilizar a ferramenta é necessário o conhecimento de ontologias. Os testes foram
realizados com três ontologias sobre assuntos distintos, como anteriormente citado. A
ontologia sobre gestão de segurança da informação norteou o desenvolvimento do protótipo.
Inicialmente elaborada por Silva et al. (2011), foi adaptada para o protótipo, pois para a
correta funcionalidade da ferramenta é necessário que as propriedades da ontologia sejam
verbos da língua portuguesa.
Com a ontologia criada no formato OWL, o primeiro passo é o cadastrá-la. Através do
menu Cadastros > Ontologia > Adicionar é possível visualizar a tela para o cadastro da
nova ontologia (Figura 10). Para cadastrar uma ontologia é necessário informar
obrigatoriamente um nome e o arquivo no formato OWL. Opcionalmente, pode-se acrescentar
uma descrição com maiores informações sobre a ontologia. É possível também editar (Figura
11) e visualizar as ontologias cadastradas (Figura 12), visualizar mais detalhes de uma
ontologia (Figura 13), excluir e realizar o download do seu respectivo arquivo (Figura 14).
47
Figura 9 - Interface do protótipo
Figura 10 – Cadastro de ontologia
Figura 11 - Edição da ontologia
Figura 12 – Ontologias cadastradas
48
Figura 13 - Detalhes da ontologia
Figura 14 - Exclusão de ontologia
Depois de cadastrada uma ontologia, é possível acessar os substantivos importados
através do menu Cadastros > Substantivos (Figura 15). Pode-se também: filtrar a lista de
substantivos por tipo (singular, plural, invariável), descrição e ontologia (Figura 16); cadastrar
substantivos manualmente (Figura 17, Figura 18), bem como editá-los (Figura 19, Figura 20).
Os substantivos cadastrados podem ser excluídos (Figura 22) ou ter seus detalhes visualizados
(Figura 21).
49
Figura 15 - Substantivos cadastrados
Figura 16 - Substantivos
cadastrados - filtro habilitado
Figura 17 - Cadastro de substantivo no singular
Figura 18 – Cadastro de substantivo no plural
Figura 19 - Edição de substantivo no singular
Figura 20 - Edição de substantivo no plural
50
Figura 21 – Detalhes do substantivo
Figura 22 - Exclusão de substantivo
Com a ontologia cadastrada e os substantivos importados, é possível iniciar as buscas.
O primeiro modelo de busca que o protótipo disponibiliza é no formato SPARQL. O usuário
deve escolher a ontologia em que deseja realizar a busca. Ao selecionar a ontologia, uma
requisição AJAX é disparada mostrando os prefixos utilizados na construção da ontologia
(Figura 23). A partir daí o usuário escreve a consulta no campo Consulta e pressiona o botão
Buscar (Figura 24).
Figura 23 - Busca em SPARQL: prefixos da ontologia
51
Figura 24 – Busca em SPARQL
Uma vez processada a consulta, a página é recarregada e o resultado pode ser
visualizado, conforme ilustrado na Figura 25.
Figura 25 - Resultado de busca em SPARQL
52
Além da consulta na linguagem SPARQL, é possível realizar buscas em linguagem
natural. Primeiramente deve-se escolher a ontologia. Depois a pergunta deve ser escrita no
campo Consulta de acordo com os formatos abordados anteriormente no trabalho (Figura
26).
Figura 26 – Busca em linguagem natural
Uma vez processada a consulta, a página é recarregada e o resultado pode ser
visualizado (Figura 27 a Figura 30).
Figura 27 – Resposta para: Quais ingredientes contém batata recheada?
Figura 28 – Resposta para: A pizza contém tomate?
53
Figura 29 – Resposta para: Que ingredientes uma pizza contém?
Figura 30 – Resposta para: Como se explora uma vulnerabilidade?
3.4 RESULTADOS E DISCUSSÃO
O presente trabalho apresentou o desenvolvimento de um protótipo de software para
buscas semânticas, através de perguntas elaboradas na língua portuguesa. Fez-se uso de
54
ontologias utilizando a linguagem OWL para a definição da base de dados. Os resultados
obtidos se mostraram satisfatórios, visto que as consultas foram generalizadas para que
pudessem atender qualquer domínio de ontologia e não apenas um domínio específico como
estabelecido na proposta. Os testes foram realizados em três diferentes ontologias de domínios
completamente distintos e pelo menos quarenta perguntas foram testadas com êxito.
Inicialmente foi utilizada uma ontologia sobre segurança da informação elaborada por
Silva et a. (2011). Após vários testes, percebeu-se que a ontologia não se adequava ao
protótipo desenvolvido, pois as propriedades da ontologia não correspondiam diretamente a
verbos da língua portuguesa. Portanto, foi necessário adaptar a ontologia sobre segurança da
informação. Além disso, as classes, as subclasses e os indivíduos na ontologia devem ser
descritos no singular já que são pluralizados pela ferramenta.
As demais restrições do trabalho ficam por conta da gramática, que fixa formatos de
perguntas. Isto acontece, pois a diversidade de regras para compor uma oração na língua
portuguesa é extremamente grande. De qualquer forma, a ferramenta GALS se mostrou
eficiente, agilizando o processo de construção da gramática.
Quanto as demais ferramentas usadas no desenvolvimento, tem-se que a especificação
das ontologias foi facilitada com a ferramenta NeOn Toolkit. A API dotNetRDF segue os
conceitos da linguagem C# e seu uso é realmente simplificado. O uso do Entity Framework
facilitou a implementação de métodos para encontrar recursos, propriedades e objetos na
ontologia a partir do sujeito, verbo e objeto da oração. Visto que em muitos casos a palavra
não é exatamente o que está cadastrado na ontologia, fez-se uso da teoria de conjuntos. União,
interseção e exclusão foram amplamente utilizadas para se encontrar exatamente um
determinado elemento.
Quanto aos trabalhos correlatos descritos, o único que se assemelha ao presente
protótipo (OnTo Busca) para efeito de comparação é o Semantic Lattes (COSTA; YAMATE,
2009). O Quadro 35 apresenta uma breve comparação.
55
funcionalidade OnTo Busca Semantic Lattes plataforma web web domínios de ontologia suportados diversos específico
reconhecimento de linguagem natural
sim, as perguntas podem ser elaboradas conforme a gramática especificada
não, as perguntas são fixas (no protótipo)
possibilidade de realizar consultas em linguagem natural
sim, as perguntas são traduzidas para consultas
SPARQL durante a execução
sim, mas como as perguntas são fixas, as consultas SPARQL também são
possibilidade de realizar consultas em SPARQL sim não
capacidade de agregar conhecimento à ontologia existente
não sim
Quadro 35 - Comparativo entre ferramentas
56
4 CONCLUSÕES
Se por um lado a web semântica aparece com o objetivo de fazer os computadores
entenderem o significado das informações contidas na internet, por outro, sem o
Processamento de Linguagem Natural esta tarefa não será fácil. As pesquisas na área de web
semântica vêm crescendo, tanto para formar ontologias a partir dos dados já existentes na
internet, como para buscar informações em ontologias criadas. Assim, o trabalho aqui
apresentado traz uma possível solução para o problema, pois trata-se do desenvolvimento de
uma ferramenta de consulta de informações em bases de dados de ontologias, tanto em
linguagem SPARQL, como através de perguntas na língua portuguesa.
Quanto ao desenvolvimento do trabalho, percebeu-se que há uma dificuldade em
formalizar a linguagem natural de forma determinística, principalmente se tratando da língua
portuguesa. Esta dificuldade acabou limitando a gramática, que não aceita todas as formas
possíveis de perguntas do idioma. A criação das ontologias também possui restrições: as
propriedades devem ser verbos da língua portuguesa e as classes e indivíduos devem estar na
sua forma singular.
Contudo, o presente trabalho superou as expectativas inicialmente propostas. Foi
desenvolvida uma ferramenta onde a partir de perguntas na língua portuguesa é possível obter
respostas e extrair conhecimento de uma base de dados de ontolgoias. Os objetivos foram
atingidos e apesar das restrições citadas, foram superados com a possibilidade de realizar
consultas em linguagem natural em mais de um domínio de ontologias. Fato comprovado e
testado com três diferentes domínios de ontologias.
As tecnologias e ferramentas utilizadas mostraram-se eficazes e tornaram mais ágil o
processo de desenvolvimento do protótipo. A ferramenta GALS norteou o desenvolvimento
da gramática. Apesar da sintaxe de Java e C# serem parecidas, as linguagens possuem
conceitos diferentes, necessitando de conhecimentos específicos para a migração do código
gerado em Java pelo GALS. Enquanto isto, o Entity Framework dispensou a criação manual
do banco de dados e facilitou muito a manipulação de listas. A biblioteca dotNetRDF se
mostrou simples e robusta para se trabalhar com a web semântica e suas linguagens OWL e
SPARQL.
57
4.1 EXTENSÕES
Existem pontos que podem ser melhorados e incrementados no protótipo desenvolvido,
sendo eles:
a) aperfeiçoar a gramática, não restringindo o tipo das perguntas elaboradas;
b) utilizar técnicas de Inteligência Artificial (IA) no reconhecimento das perguntas;
c) permitir a agregação de conhecimento em linguagem SPARQL e em linguagem
natural;
d) implementar cadastros de verbos e de sinônimos para substantivos e verbos para
melhorar exatidão das consultas;
e) permitir que as consultas em linguagem natural sejam realizadas sem a
necessidade de escolha de ontologia;
f) realizar saídas em forma de texto corrido na língua portuguesa.
58
REFERÊNCIAS BIBLIOGRÁFICAS
APACHE SOFTWARE FOUNDATION. Jena: a semantic web framework for Java. [S.l.], [2011?]. Disponível em: <http://jena.sourceforge.net/index.html>. Acesso em: 11 set. 2011.
BERNERS-LEE, Tim; HENDLER, James; LASSILA, Ora. The semantic web. Scientific American, [S.l.], v. 5, n. 284, p. 34-43, May 2001. Disponível em: <http://www.dcc.uchile.cl/~cgutierr/cursos/IC/semantic-web.pdf>. Acesso em: 07 set. 2011.
BRAVO, Carlos O. Geração automática de ontologias para a web semântica. 2010. 136 f. Dissertação (Mestrado em Informática) - Departamento de Ciência da Computação, Universidade de Brasília, Brasília. Disponível em: <http://monografias.cic.unb.br/dspace/bitstream/123456789/250/1/UnB_CIC_Dissertacao_Mestrado_Impressao_Carlos_Bravo.pdf>. Acesso em: 06 set. 2011.
BREITMAN, Karin K. Web semântica: a internet do futuro. Rio de Janeiro: LTC, 2005.
COSTA, Anauê P.; YAMATE, Fabio S. Semantic Lattes: uma ferramenta de consulta de informações acadêmicas da base Lattes baseada em ontologias. 2009. 97 f. Trabalho de Conclusão de Curso (Graduação em Engenharia de Computação) - Departamento de Engenharia de Computação e Sistemas Digitais, Universidade de São Paulo, São Paulo. Disponível em: <http://www.pcs.usp.br/~pcspf/2009/Trabalhos/Cooperativo/G4/monografia.pdf>. Acesso em: 04 set. 2011.
GAGNON, Michel. Processamento da linguagem natural. [S.l.], 2000. Disponível em: <http://www.professeurs.polymtl.ca/michel.gagnon/Disciplinas/Bac/IA/PLN/pln.html>. Acesso em: 06 set. 2011.
GESSER, Carlos E. GALS: gerador de analisadores léxicos e sintáticos. 2003. 150 f. Trabalho de Conclusão de Curso (Bacharelado em Ciência da Computação) – Centro Tecnológico, Universidade Federal de Santa Catarina, Florianópolis. Disponível em: <http://projetos.inf.ufsc.br/arquivos_projetos/projeto_353/Gals.pdf>. Acesso em: 19 jun. 2012.
GOTTSCHALG-DUQUE, Cláudio. Sirilico: uma proposta para um sistema de recuperação de informação baseado em teorias da linguística computacional e ontologia. 2005. 118 f. Tese (Doutorado em Ciência da Informação) - Escola de Ciência da Informação, Universidade Federal de Minas Gerais, Belo Horizonte. Disponível em: <http://www.bibliotecadigital.ufmg.br/dspace/bitstream/1843/EARM-7HBND8/1/doutorado___claudio_gottschalg_duque___parcial.pdf>. Acesso em: 19 set. 2011.
59
GRUBER, Thomas R. A translation approach to portable ontology specifications. [S.l.], 1993. Disponível em: <http://ksl.stanford.edu/pub/KSL_Reports/KSL-92-71.ps.gz>. Acesso em: 14 jul. 2012.
JACOBS, Ian. Sobre o consórcio W3C. [S.l.], 2008. Disponível em: <http://www.w3c.br/sobre/#history-head>. Acesso em: 02 set. 2011.
JQUERY FOUNDATION. jQuery: write less, do more. [S.l.], 2012. Disponível em: <http://jquery.com>. Acesso em: 22 jun. 2012.
LERMAN, Julie. Building an MVC 3 APP with code first and Entity Framework 4.1. [S.l.], 2011. Disponível em: <http://msdn.microsoft.com/en-us/data/gg685467.aspx>. Acesso em: 08 jun. 2012.
MENEGUSSO, Gustavo. Análise pragmática de textos orais e escritos. [Santa Maria], 2008. Disponível em: <http://www.cesnors.ufsm.br/projetos/textos-academicos/Modelo%20de%20Artigo%20-%20Analise%20Pragmatica%20de%20Textos%20Orais%20e%20Escritos%20-%20Menegusso.pdf>. Acesso em: 19 set. 2011.
MICROSOFT. ASP.NET MVC 3 Razor. [S.l.], 2012. Diponível em: <http://msdn.microsoft.com/en-us/vs2010trainingcourse_aspnetmvc3razor.aspx>. Acesso em: 22 jun. 2012.
MICROSOFT ASP.NET TEAM. ASP.NET MVC overview. [S.l.], 2009. Disponível em: <http://www.asp.net/mvc/tutorials/older-versions/overview/asp-net-mvc-overview>. Acesso em: 08 jun. 2012.
MOTTA, Enrico. NeOn toolkit 1.2 manual. [S.l.], 2012. Disponível em: <http://www.neon-toolkit.org/index.php?option=com_docman&task=doc_download&gid=5>. Acesso em: 20 jun. 2012.
MÜLLER, Daniel N. Processamento de linguagem natural. Porto Alegre, 2003. Disponível em: <http://www.inf.ufrgs.br/~danielnm/docs/pln.pdf>. Acesso em: 03 set. 2011.
OLIVEIRA, Fabio A. D. Processamento de linguagem natural: princípios básicos e a implementação de um analisador sintático de sentenças da língua portuguesa. Porto Alegre, 2009. Disponível em: <http://www.inf.ufrgs.br/gppd/disc/cmp135/trabs/992/Parser/parser.html>. Acesso em: 03 set. 2011.
PRUD'HOMMEAUX, Eric; SEABORNE, Andy. SPARQL query language for RDF. [S.l.], 2008. Disponível em: <http://www.w3.org/TR/rdf-sparql-query/>. Acesso em: 04 set. 2011.
RDF WORKING GROUP. Resource Description Framework (RDF). [S.l.], 2004. Disponível em: <http://www.w3.org/RDF/>. Acesso em: 03 set. 2011.
60
SCHNEIDER, Marvin O. Processamento de Linguagem Natural (PLN). Campinas, 2001. Disponível em: <http://moschneider.tripod.com/pln.pdf>. Acesso em: 05 set. 2011.
SILVA, Paulo Fernando et al. Uma ontologia para gestão de segurança da informação. In: INTERNACIONAL WORKSHOP ON METAMODELS ONTOLOGIES AND SEMANTIC TECHNOLOGIES, 6th, 2011, Gramado. Proceedings… [S.l.]: CEUR, 2011. p. 141- 146. Disponível em: <http://ceur-ws.org/Vol-776/ontobras-most2011_paper15.pdf>. Acesso em: 01 mar. 2012. VESSE, Rob. dotNetRDF: an open source C# .net library for RDF. [S.l.], 2012. Disponível em: <http://www.dotnetrdf.org/default.asp>. Acesso em: 20 jun. 2012.
VIEIRA, Renata; LIMA, Vera L. S. Linguística computacional: princípios e aplicações. In: MARTINS, Ana T.; BOLRGES, Díbio L. (Org.). Jornadas de atualização em inteligência artificial. Fortaleza: SBC, 2001. v. 3, p. 47-86. Disponível em: <http://www.di.ubi.pt/~pln/jaia12-vf.pdf>. Acesso em: 05 set. 2011.
W3C BRASIL. Web semântica. [S.l.], 2011. Disponível em: <http://www.w3c.br/Padroes/WebSemantica>. Acesso em: 02 set. 2011.
W3C OWL WORKING GROUP. OWL 2 web ontology language document overview. [S.l.], 2009. Disponível em: <http://www.w3.org/TR/owl2-overview/>. Acesso em: 04 set. 2011.
61
APÊNDICE A – Ontologia: gestão de segurança da informação
A seguir é detalhada a ontologia sobre gestão de segurança da informação utilizada no
protótipo. Foram geradas imagens a partir da ferramenta NeOn Toolkit que mostram os
relacionamentos entre classes, indivíduos e propriedades. As classes e subclasses são
ilustradas na Figura 31. Os indivíduos de cada classe, bem como seus relacionamentos
(propriedades) com outros indivíduos são apresentados nas demais figuras (Figura 32 a Figura
44).
Figura 31 - Ontologia sobre Gestão de Segurança da Informação: classes
Figura 32 - Indivíduos da classe Malware e
seus relacionamentos
Figura 33 - Indivíduos da classe EventoNatural
e seus relacionamentos
62
Figura 34 - Indivíduos da classe AtacanteInterno e seus relacionamentos
Figura 35 - Indivíduos da classe AtacanteExterno e seus relacionamentos
Figura 36 - Indivíduos da classe AmbienteFisico e seus relacionamentos
Figura 37 - Indivíduos da classe Software e seus relacionamentos
Figura 38 - Indivíduos da classe ControleFisico e seus relacionamentos
63
Figura 39 - Indivíduos da classe Hardware e seus relacionamentos
Figura 40 - Indivíduos da classe InformacaoDigital e seus relacionamentos
Figura 41 - Indivíduos da classe InformacaoFisica e seus relacionamentos
Figura 42 - Indivíduos da classe ControleLogico e seus relacionamentos
64
Figura 43 - Indivíduos da classe VulnerabilidadeLogica e seus relacionamentos
Figura 44 - Indivíduos da classe VulnerabilidadeFisica e seus relacionamentos
65
APÊNDICE B – Ontologia: Alimentos
A seguir é detalhada a ontologia sobre alimentos utilizada no protótipo. Foram geradas
imagens a partir da ferramenta NeOn Toolkit que mostram os relacionamentos entre classes,
indivíduos e propriedades. As classes e subclasses são ilustradas na Figura 45. Os indivíduos
de cada classe, bem como seus relacionamentos (propriedades) com outros indivíduos são
apresentados nas demais figuras (Figura 46 a Figura 50).
Figura 45 – Ontologia sobre Alimentos: classes
Figura 46 – Indivíduos da classe Bebida e seus relacionamentos
Figura 47 – Indivíduos da classe Suco e seus relacionamentos
Figura 48 – Indivíduos da classe Salgado e seus relacionamentos
66
Figura 49 – Indivíduos da classe Ingrediente e seus relacionamentos
Figura 50 – Indivíduos da classe Doce e seus relacionamentos
67
APÊNDICE C – Ontologia: Futebol
A seguir é detalhada a ontologia sobre futebol utilizada no protótipo. Foram geradas
imagens a partir da ferramenta NeOn Toolkit que mostram os relacionamentos entre classes,
indivíduos e propriedades. As classes e subclasses são ilustradas na Figura 51. Os indivíduos
de cada classe, bem como seus relacionamentos (propriedades) com outros indivíduos são
apresentados nas demais figuras (Figura 52 a Figura 58).
Figura 51 - Ontologia sobre futebol: classes
Figura 52 – Indivíduos da
classe Liga e seus relacionamentos
Figura 53 – Indivíduos da
classe Copa e seus relacionamentos
Figura 54 – Indivíduos da classe Continente e seus
relacionamentos
68
Figura 55 – Indivíduos da classe Pais e seus
relacionamentos
Figura 56 – Indivíduos da classe Posicao e seus
relacionamentos
Figura 57 – Indivíduos da classe Time e seus relacionamentos
Figura 58 – Indivíduos da classe Jogador e seus relacionamentos
