algoritmos para interoperabilidade entre...
TRANSCRIPT
UNIVERSIDADE CATÓLICA DE PELOTAS
ESCOLA DE INFORMÁTICA
PROGRAMA DE PÓS-GRADUAÇÃO EM INFORMÁTICA
Algoritmos para Interoperabilidade entre Ontologias
por
Verlani Timm Hinz
Dissertação apresentada como requisito parcial para a obtenção do grau de
Mestre em Ciência da Computação
Orientador: Prof. Dr. Luiz Antônio Moro Palazzo
Pelotas, julho de 2007.
Dedico este trabalho ao filho Erick,
que acompanhou o desenvolvimento deste trabalho, mesmo antes do seu nascimento
e que se tornou a razão da minha vida.
AGRADECIMENTOS
Sobre tudo e todos, agradeço a Deus. Foi Ele quem me deu sabedoria, discernimento,
forças e amparo necessário nos momentos que precisei.
Sou eternamente grata aos meus Pais, Eno e Vanda, que se enchem de alegria e
orgulho com cada conquista de suas filhas.
Agradeço a cada um da minha família, que torceu e partilhou de cada passo deste
trabalho; em especial às minhas irmãs Ervanda, Vanderlisa e Elizabete.
Ao meu marido Luciano, uma pessoa muito especial, que sempre acreditou em mim,
me deu forças para continuar, principalmente quando nasceu nosso filho Erick, uma grande
alegria, que serviu de parada no meio deste Mestrado.
Ao orientador Prof. Dr. Luiz Antonio Moro Palazzo, o grande incentivador deste
trabalho e que mais do que orientar, soube conduzir e aconselhar. Obrigada por toda sua
compreensão, paciência e principalmente disponibilidade.
Aos amigos do mestrado, pela amizade constituída, esta turma tão especial, onde cada
um deles que de uma forma ou de outra estiveram presentes e contribuíram para o sucesso
deste trabalho.
À direção (Eduardo Cassal), coordenação dos cursos de Tecnologia (Marislei e
Mário), colegas do curso de Análise e Desenvolvimento de Sistemas (Edécio, Rosaura, João,
Paulo, Bianca, Cibele, André, Guilherme, Eduardo Monks, Márcia), colegas do curso de
Marketing (Irapuã, Helena, Letícia, Valéria, Ana Paula, Liliane, Sérgio, Luiz, Rafael,
Alexandre), demais funcionários e alunos da Faculdade de Tecnologia Senac, pelo incentivo e
carinho.
Às minhas colegas e amigas do Jornal Diário Popular (Lara, Rita, Clésia e Graça),
que participam das minhas conquistas desde a minha graduação.
SUMÁRIO
LISTA DE FIGURAS............................................................................................................ 6
LISTA DE TABELAS........................................................................................................... 8
LISTA DE QUADROS.......................................................................................................... 9
LISTA DE ABREVIATURAS E SIGLAS........................................................................... 11
RESUMO ............................................................................................................................ 12
ABSTRACT ........................................................................................................................ 13
1. Introdução ................................................................................................................ 14
1.1 Motivação ............................................................................................................ 14
1.2 Contexto de pesquisa ............................................................................................ 15
1.3 Objetivos .............................................................................................................. 16
1.4 Trabalhos relacionados ......................................................................................... 16
1.5 Contribuição da dissertação .................................................................................. 19
1.6 Organização do texto ............................................................................................ 19
2. Ontologias................................................................................................................ 20
2.1 Definição.............................................................................................................. 20
2.2 Vantagens do uso de ontologias ............................................................................ 21
2.3 Composição.......................................................................................................... 22
2.4 Modelagem .......................................................................................................... 23
2.4.1 Restrição de valor ............................................................................................. 27
2.4.2 Restrições de cardinalidade............................................................................... 28
2.4.3 Representação das instâncias ............................................................................ 30
2.5 Considerações do Capítulo ................................................................................... 31
3. Representação de Ontologias.................................................................................... 32
3.1 Padrão XML, RDF e OWL................................................................................... 32
3.1.1 XML ................................................................................................................ 33
3.1.2 RDF.................................................................................................................. 34
3.1.3 OWL ................................................................................................................ 35
3.2 Grafos e Matrizes de Adjacência .......................................................................... 38
3.2.1 Principais Vantagens da Utilização de Gramática de Grafos ............................. 41
3.3 Representação contextual ..................................................................................... 41
3.4 Considerações do capítulo .................................................................................... 43
4. Interoperabilidade entre ontologias........................................................................... 44
4.1 Mecanismos de Interoperabilidade........................................................................ 44
4.1.1 A aplicação dos mecanismos ............................................................................ 47
4.2 Conciliação de vocabulários ................................................................................. 50
4.2.1 Dublin Core...................................................................................................... 50
4.2.2 FOAF (Friend Of A Friend).............................................................................. 52
4.3 Conversão de ontologias....................................................................................... 53
4.3.1 Parser Thea...................................................................................................... 54
4.3.2 Ambiente SWI-Prolog ...................................................................................... 56
4.3.3 Exemplo ........................................................................................................... 57
4.4 Operadores Relacionais ........................................................................................ 60
4.4.1 Definição.......................................................................................................... 61
4.5 Algoritmos ........................................................................................................... 67
4.6 Exemplo de interoperabilidade dinâmica entre ontologias..................................... 73
4.6.1 Ontologia do Ambiente..................................................................................... 77
4.6.2 Ontologia do Agente......................................................................................... 79
4.7 Considerações do capítulo .................................................................................... 81
5. Conclusões ............................................................................................................... 82
5.1 Trabalhos futuros.................................................................................................. 83
5.2 Publicações realizadas .......................................................................................... 83
6. Bibliografia .............................................................................................................. 85
LISTA DE FIGURAS
Figura 1.1: Plugin PrompTab disponível no ambiente Protegé............................................. 17
Figura 1.2: Entradas e saídas das etapas de alinhamento do CATO....................................... 18
Figura 2.1: Representação hierárquica de uma ontologia ...................................................... 23
Figura 2.2: Hierarquia de propriedades................................................................................. 24
Figura 2.3: Propriedade Simétrica ........................................................................................ 25
Figura 2.4: Propriedade Transitiva ....................................................................................... 25
Figura 2.5: Propriedade Funcional ....................................................................................... 25
Figura 2.6: Propriedade Reflexiva........................................................................................ 26
Figura 2.7: Propriedade Equivalente .................................................................................... 26
Figura 2.8: Definição de restrições em OWL, no ambiente Protegé. .................................... 27
Figura 2.9: Cardinalidade da Classe Concreta ...................................................................... 29
Figura 2.10: Definição da restrição Termo juntamente com a classe e condição necessária, no
Protegé................................................................................................................................. 29
Figura 2.11: Exemplo de Instanciação da Classe Termo ....................................................... 30
Figura 3.1: O modelo em camada para as linguagens de ontologias. ..................................... 32
Figura 3.2: Grafo RDF representando uma tripla. ................................................................. 35
Figura 3.3: Duas representações de um grafo orientado. a) um grafo orientado G que tem 4
vértices e 4 arestas. b) uma representação de G como matriz de adjacências......................... 39
Figura 3.4: Duas representações de um grafo orientado. a) um grafo orientado G que tem 3
vértices e 3 arestas. b) uma representação de G como matriz de adjacências......................... 40
Figura 3.5: Representações de um grafo orientado. a) um grafo orientado G que tem 3 vértices
e 3 arestas. b) uma representação de G como matriz de adjacências...................................... 40
Figura 3.6: Matriz de Adjacências representando conceitos e relacionamentos. ................... 42
Figura 3.7: Seqüência de passos do processo de conversão de ontologias ............................. 42
Figura 3.8: Estratégia para a integração de ontologias .......................................................... 43
Figura 4.1: Exemplo do mecanismo de combinação de ontologias........................................ 45
Figura 4.2: Exemplo do mecanismo de integração de ontologias .......................................... 45
Figura 4.3: Exemplo do mecanismo de alinhamento de ontologias. ...................................... 46
Figura 4.4: Exemplo do mecanismo de mapeamento de ontologias ...................................... 46
Figura 4.5: Exemplo de combinação de ontologias............................................................... 47
Figura 4.6: Exemplo de integração de ontologias ................................................................. 48
Figura 4.7: Exemplo de mapeamento de ontologias.............................................................. 49
Figura 4.8: Exemplo de alinhamento de ontologias .............................................................. 49
Figura 4.9: Matriz de adjacência de mat(C,R) ...................................................................... 53
Figura 4.10: Parte da Ontologia Wines criada no ambiente Protege, representando as classes e
subclasses e o código gerado no parser Thea. (PROTEGE, 2006a)....................................... 58
Figura 4.11: Parte da Ontologia Wines criada no ambiente Protegé, representando as
instâncias. (PROTEGE, 2006a) ............................................................................................ 59
Figura 4.12 Exemplo de interoperabilidade entre ontologias utilizando operadores relacionais
............................................................................................................................................ 60
Figura 4.13: Ontologia O1 modelada no Protegé, visualizando os conceitos e instâncias
associadas ............................................................................................................................ 62
Figura 4.14: Ontologia 01, modelada no Protegé, visualizando os (relacionamentos) ........... 62
Figura 4.15: Ontologia O1 modelada no Protegé, visualizando os conceitos e relacionamentos
............................................................................................................................................ 63
Figura 4.16: Ontologia O2, modelada no Protege, visualizando os conceitos........................ 65
Figura 4.17: Ontologia O2, modelada no Protege, visualizando os relacionamentos ............. 66
Figura 4.18: Ontologia O2, modelada no Protegé, visualizando os conceitos e relacionamentos
............................................................................................................................................ 66
Figura 4.19: Exemplo de aplicação dos mecanismos de interoperabilidade........................... 74
Figura 4.20: Exemplo de conciliação de vocabulários utilizados na intersecção.................... 75
Figura 4.21: Exemplo de diferença com relacionamento...................................................... 75
Figura 4.22: Ontologia do ambiente, utilizando termos do DC modelada no Protegé. ........... 78
Figura 4.23: Ontologia do agente, utilizando termos do FOAF, modelada no Protege........... 80
LISTA DE TABELAS Tabela 4.1: Elementos do Dublin Core................................................................................. 51
Tabela 4.2: Termos do FOAF............................................................................................... 52
Tabela 4.3: Correspondência entre os termos do Dublin Core e os dados de um evento. ....... 77
Tabela 4.4: Termos complementares do Congresso .............................................................. 78
Tabela 4.5: Exemplo utilizando os termos do FOAF ............................................................ 79
LISTA DE QUADROS
Quadro 3.1: Exemplo de código XML. Figura retirada de (ANTONIOU; VAN HARMELEN,
2004) ................................................................................................................................... 34
Quadro 3.2: Trecho de código RDF...................................................................................... 35
Quadro 3.3: Parte de código OWL representando a versão e namespaces ............................. 37
Quadro 3.4: Parte de código OWL representando alguns elementos que formam a estrutura
inicial de um documento OWL. ............................................................................................ 38
Quadro 4.1: Rotina Prolog para transformar uma matriz em lista de triplas .......................... 53
Quadro 4.2: Rotina Prolog para transformação em triplas..................................................... 54
Quadro 4.3: Trecho de código OWL em termos Prolog ........................................................ 54
Quadro 4.4: Trecho de código OWL em termos Prolog ........... Erro! Indicador não definido.
Quadro 4.5: Trecho de código OWL contendo as descrições em termos Prolog.................... 55
Quadro 4.6: Trecho de código OWL contendo as restrições em termos Prolog ..................... 55
Quadro 4.7: Trecho de código OWL mostrando a seqüência criada pelo parser Thea........... 55
Quadro 4.8: Trecho de código OWL em termos Prolog ........... Erro! Indicador não definido.
Quadro 4.9: Trecho de código OWL contendo predicados dinâmicos em termos Prolog...... 56
Quadro 4.10: Comando do Prolog utilizando o parser Thea.................................................. 56
Quadro 4.11: Parte da Ontologia Wines2 gerado no Parser, representando a relação é-um
entre classes e subclasses. .................................................................................................... 58
Quadro 4.12: Parte da Ontologia Wines2.owl gerado no Parser, representando as instâncias. 59
Quadro 4.13: Trecho de código OWL da ontologia O1, visualizando conceitos e
relacionamento..................................................................................................................... 63
Quadro 4.14: Trecho de código OWL da ontologia O1, gerado no parser Thea .................... 64
Quadro 4.15: Trecho de código OWL gerado no Parser Thea, representando as subclasses de
O1........................................................................................................................................ 64
Quadro 4.16: Trecho de código OWL gerado no Parser Thea, representando as instâncias e
O1........................................................................................................................................ 65
Quadro 4.17: Trecho do código OWL gerado a partir da ontologia O2 ................................. 66
Quadro 4.18: Exemplo de união ........................................................................................... 67
Quadro 4.19: Exemplo de intersecção .................................................................................. 67
Quadro 4.20: Exemplo de diferença ..................................................................................... 67
Quadro 4.21: Resultado da aplicação do operador relacional ................................................ 68
Quadro 4.22: Algoritmo de união utilizando o operador op1 ............................................... 68
Quadro 4.23: Predicado auxiliar da união............................................................................. 68
Quadro 4.24: Exemplo1 do algoritmo de união utilizando o ambiente SWI-Prolog .............. 69
Quadro 4.25: Exemplo2 do algoritmo de união utilizando o ambiente SWI-Prolog .............. 69
Quadro 4.26: Algoritmo de intersecção utilizando o operador relacional op2 ....................... 70
Quadro 4.27: Predicado auxiliar da intersecção .................................................................... 70
Quadro 4.28: Exemplo1 do algoritmo de intersecção utilizando o ambiente SWI-Prolog...... 71
Quadro 4.29: Exemplo2 do algoritmo de intersecção utilizando o ambiente SWI-Prolog...... 71
Quadro 4.30: Algoritmo de diferença utilizando o operador op3........................................... 71
Quadro 4.31: Predicado auxiliar da diferença ....................................................................... 72
Quadro 4.32: Exemplo1 do algoritmo de diferença utilizando o ambiente SWI-Prolog......... 72
Quadro 4.33: Exemplo2 do algoritmo de diferença utilizando o ambiente SWI-Prolog......... 73
Quadro 4.34: Algoritmo do relacionado-com utilizando o operador relacional op4............... 76
Quadro 4.35: Exemplo do algoritmo relacionado-com utilizando o ambiente SWI-Prolog.... 77
Quadro 4.36: Código OWL gerado da ontologia do ambiente, utilizando termos do DC....... 79
Quadro 4.37: Trecho de código OWL da ontologia do agente, utilizando termos FOAF....... 80
LISTA DE ABREVIATURAS E SIGLAS
DAML DARPA Agent Markup Language
DC Dublin Core
DL Description Logic
FOAF Friend Of A Friend
HTML Hypertext Markup Language
IA Inteligência Artificial
OIL Ontology Inference Layer
OWL Web Ontology Language
RDF Resource Description Framework
RDFS Resource Description Framework Schema
RDQL RDF Data Query Language
RQL RDF Query Language
SBC Sistemas Baseados em Conhecimento
SQL Structure Query Language
URI Uniform Resource Identifiers
W3C World Wide Web Consortium
XML eXtensible Markup Language
RESUMO
Recentemente, tem crescido o interesse sobre o tema Ontologias, pois estas objetivam
capturar conhecimento consensual entre pessoas e aplicações, permitindo o reuso e
compartilhamento de informações. Para estes propósitos, são necessários mecanismos que
garantam a interoperabilidade semântica e compatibilidade de informações. O presente
trabalho propõe desenvolver algoritmos para interoperabilidade entre ontologias, utilizando
operadores relacionais. Para isso, inicialmente foi feito um estudo básico, mas aprofundado,
sobre as formas de interoperabilidade entre ontologias e sua aplicação em diferentes
ambientes. Foram estudados também formalismos de especificação como gramática de grafos
e matriz de adjacências para representar ontologias, assim como, a utilização de parsers para
converter ontologias no formato OWL em representação de matrizes. Os padrões Dublin Core
e FOAF, foram estudados e utilizados a fim de tratar a questão da conciliação de
vocabulários. Como verificações da aplicabilidade da medida foram demonstrados dois
exemplos de interoperabilidade dinâmica de ontologias aplicadas a domínios específicos.
Palavras-chave: Ontologias, Mecanismos de Interoperabilidade, Gramática de Grafos,
Matriz de Adjacências, Algoritmos, Parsers, OWL.
TITLE: “ALGORITHMS FOR ONTOLOGIES INTEROPERABILITY”
ABSTRACT
Nowadays the interest for the theme ontologies has steadily increased, as it aims at to
capture consensual knowledge between people and applications, allowing reusing and sharing
information. With this purpose, mechanisms are demanded to guarantee semantic
interoperability, that is, the identification and compatibility of information. The present study
proposes to development the algorithms to interoperability among ontologies. Hence, it
intends to obtain more semantic flexibility and to reach better levels of description in the
information that characterize the context of a computational environment. Initially, a basic but
deep study, was done about the ways of interoperability among ontologies and its applications
in different environments. Formality of specification as grammatical of graphs and matrix of
adjacencies to represent ontologies and the use of parsers for conversion of code OWL in
representation of matrices had also been studied. The patterns Dublin Core and FOAF, were
studied and used in order to address the issue of reconciliation of vocabularies. For
verification of the applicability of the measure, it was shown to an example of dynamic
interoperability of ontologies and an algorithm that can be applied in several scenes.
Keywords: Ontology, Interoperability Mechanisms, Graphs Grammatical,
Adjacencies Matrix, Algorithms, Parsers, OWL.
14
1. Introdução
Este capítulo descreve sobre as motivações para a realização deste trabalho, bem
como, o contexto de pesquisa em que ele se encontra, seus objetivos e trabalhos relacionados.
Em seguida, são abordadas as expectativas com relação à contribuição desta dissertação e
ainda, como o texto em si está organizado.
1.1 Motivação
Nos últimos anos, o grande volume de dados disponíveis tem conferido importância
significativa às técnicas de organização da informação. Essas técnicas buscam melhorias no
tratamento de dados, atuando em sua seleção, processamento, recuperação e disseminação.
Apesar da grande quantidade de dados disponíveis, não existe um formato padrão de
armazenamento, dificultando sua integração e utilização. Na medida em que este volume de
dados cresce também aumenta a necessidade de gerenciá-los.
Diante deste cenário, o uso de ontologias tem recebido atenção na organização do
conteúdo, pelo fato de terem como objetivo promover um entendimento comum e
compartilhado sobre um domínio, que pode ser comunicado entre pessoas e sistemas de
aplicação (ANTONIOU; HARMELEN, 2004).
Uma ontologia define um vocabulário específico usado para descrever certa
realidade, mais um conjunto de decisões explícitas fixando de forma rigorosa o significado
pretendido para o vocabulário. Uma ontologia envolve, então, um vocabulário de
representação que captura os conceitos e relações em algum domínio e um conjunto de
axiomas, que restringem a sua interpretação.
Uma das vantagens no uso de ontologias é a possibilidade da manutenção e
explicação de tudo que ocorre dentro de um determinado domínio de conhecimento, além de
habilitar o reuso do conhecimento. Outra vantagem é que o conhecimento pode ser acessado e
compartilhado por todos, não ficando centralizado em uma só pessoa.
Dessa forma, o uso de ontologias permite a integração de informações e
compartilhamento de bases de conhecimento distribuídas, contribuindo para a maior
disponibilidade de informação.
No entanto para que esta comunicação seja possível devem ser utilizados mecanismos
que garantam a interoperabilidade entre ontologias, assim como o desenvolvimento de bons
algoritmos que garantam a interoperabilidade entre ontologias, aliado ao emprego de
15
operadores relacionais adequados, são essenciais para que estes mecanismos funcionem de
maneira eficiente. Sendo que, estes algoritmos devem operar em ambientes pervasivos que
permitem ao usuário ter acesso a seu ambiente computacional independente de localização,
tempo e equipamento.
Deste cenário decorre a principal motivação para este trabalho, o qual pretende
apresentar uma proposta para o desenvolvimento de algoritmos, utilizando operadores
relacionais, que garantam a interoperabilidade entre ontologias, sendo os mesmos utilizados
em tempo real, em ambientes pervasivos, onde a entrada e saída de agentes ocorra de maneira
contínua.
1.2 Contexto de pesquisa
Este trabalho está inserido no projeto OPEN (Ontology-Driven Pervasive
Environment), que tem como objetivo geral a proposição de um middleware para execução de
aplicações distribuídas, móveis e conscientes do contexto em um ambiente pervasivo aberto,
onde a entrada e saída de agentes é modelada por meio de ontologias dinâmicas. (OPEN,
2006).
O Projeto OPEN, tira partido da complementaridade dos estudos realizados nos
projetos GRADEp e CVA-ON para propor o desenvolvimento de um ambiente pervasivo
aberto, capaz de reconhecer e processar a entrada e saída de agentes. A idéia básica é
empregar os modelos de integração de ontologias desenvolvidos no Projeto CVA-ON para
modelar a entrada e saída de agentes do ambiente GRADEp em tempo real, permitindo a
auto-configuração dinâmica de recursos e serviços de modo a otimizar o atendimento das
demandas dos agentes.
O uso de ontologias na modelagem de recursos, serviços e agentes, na forma proposta
permite a evolução dinâmica do ambiente através de um formalismo escalável, cujo emprego
atual vem crescendo aceleradamente através de iniciativas como a Web Semântica, dentre
outras.
16
1.3 Objetivos
O objetivo geral deste trabalho é desenvolver algoritmos para interoperabilidade entre
ontologias utilizando operadores relacionais para atender situações de acoplamento
ontológico.
Para atingir o objetivo geral acima proposto, destacam-se os seguintes objetivos
específicos:
• Aprofundar o estudo teórico sobre as formas para interoperabilidade entre
ontologias;
• Pesquisar padrões, métodos e medidas de similaridade semântica usadas no
processo de interoperabilidade entre ontologias;
• Estudar formalismos de especificação como gramática de grafos e matriz de
adjacências para representar ontologias.
• Investigar os algoritmos existentes para interoperabilidade entre ontologias.
1.4 Trabalhos relacionados
Feita uma revisão de literatura, foram encontrados alguns trabalhos que possuem
como proposta a implementação de algoritmos para interoperabilidade entre ontologias,
aplicando-se os mecanismos como integração, combinação, alinhamento e mapeamento de
ontologias, sendo que os mesmos não abordam operadores específicos utilizados no
desenvolvimento destes.
Dentre elas, podemos citar o conjunto de ferramentas PROMPT apresentado em
(NOY; MUSEN, 2003). Dentre as ferramentas deste conjunto, citamos: iPROMPT, uma
ferramenta interativa para combinação de ontologias; AnchorPROMPT, uma ferramenta
automática baseada em grafos para alinhamento de ontologias; PROMPTFactor, uma
ferramenta para extração de partes de ontologias e PROMPTDiff, uma ferramenta para
identificação de diferenças entre duas versões da mesma ontologia. Além disso, o Protegé,
possui um plugin chamado PrompTab onde se é possível aplicar mecanismos de
interoperabilidade, conforme demonstra a Figura 1.1.
17
Figura 1.1: Plugin PrompTab disponível no ambiente Protegé
Além destas, o Componente para Alinhamento Taxonômico de Ontologias – CATO
(FELICÍSSIMO, 2004), é uma estratégia encontrada para interoperabilidade de ontologias,
pois alinha automaticamente as taxonomias de ontologias comparadas. O alinhamento
realizado é obtido em três etapas executadas seqüencialmente. A primeira etapa compara
lexicalmente os conceitos das ontologias entradas e usa um mecanismo de poda estrutural dos
conceitos associados como condição de parada. A segunda etapa compara estruturalmente as
hierarquias das ontologias identificando as similaridades entre suas sub-árvores comuns. A
terceira etapa refina os resultados da etapa anterior classificando os conceitos identificados
como similares em bem similares ou pouco similares, de acordo com um percentual de
similaridade predefinido. A Figura 1.2 demonstra a estratégia utilizada pelo CATO para o
alinhamento das ontologias.
18
Figura 1.2: Entradas e saídas das etapas de alinhamento do CATO.
Ao concluir as três etapas de execução, o CATO identifica as classes equivalentes,
i.e., aquelas que satisfazem todas as condições de cada uma de suas etapas, e realiza o
alinhamento.
Além destes trabalhos outras iniciativas têm ocorrido, entretanto não atingem o
objetivo proposto neste trabalho, o qual pretende, então, mostrar o desenvolvimento de
algoritmos para interoperabilidade entre ontologias que propiciam a comunicação entre elas,
para isso foram utilizados operadores relacionais que podem ser utilizados nos mecanismos de
interoperabilidade existentes.
19
1.5 Contribuição da dissertação
A principal contribuição deste trabalho é o desenvolvimento de algoritmos que
permitem a interoperabilidade entre ontologias, podendo ser utilizados em tempo real, em
ambientes pervasivos onde a entrada e saída de agentes ocorrem de maneira contínua.
Além disso, espera-se contribuir com este trabalho para um maior entendimento do
assunto ontologias, principalmente na questão da interoperabilidade, pois além de apresentar
uma revisão bibliográfica sobre a mesma, apresenta exemplos práticos e fornece um conjunto
de referências que podem ser exploradas com mais detalhes.
1.6 Organização do texto
O texto está organizado da seguinte forma. O Capítulo 2 é referente aos conceitos e
definições de ontologia, assim como suas vantagens, sua composição e modelagem. O
capítulo 3 descreve a representação de ontologias, onde inicialmente é feita uma breve
explanação dos conceitos das linguagens XML, RDF e OWL, a seguir são mostrados os
conceitos e importância da representação através de grafos e matriz de adjacências e a
representação contextual dos mecanismos. O capítulo 4 aborda aspectos relativos à
interoperabilidade entre ontologias descrevendo os mecanismos estudados como a integração,
combinação, alinhamento e mapeamento, assim como é exemplificado cada um destes
mecanismos. São abordados também neste capítulo, a conciliação de vocabulários utilizando
os padrões Dublin Core e FOAF, o método utilizado para converter ontologias no formato
OWL em matriz de adjacências, os operadores relacionais de união, intersecção e diferença,
assim como os algoritmos desenvolvidos neste trabalho. Exemplos de interoperabilidade
dinâmica entre ontologias também são demonstrados neste item, a fim de validar a proposta
deste trabalho. Além disso, também são apresentados as conclusões, assim como os trabalhos
futuros e as publicações realizadas ao longo do desenvolvimento deste trabalho, nos capítulos
6 e 7, respectivamente.
20
2. Ontologias
Neste capítulo é apresentada uma breve definição de ontologias, algumas vantagens
de uso, sua composição básica, assim como a modelagem utilizada para sua construção.
2.1 Definição
A palavra ontologia tem a sua origem na Filosofia, onde significa uma explicação
sistemática da existência. A disciplina de computação resgatou este termo, inserindo-o num
novo contexto, apesar de próximo do significado original. Neste sentido, apesar dos múltiplos
significados do ser, ele faz referência a um único princípio, que une todos estes múltiplos
significados.
No entanto, é impossível representar o mundo real, ou mesmo alguma parte dele, com
todos os detalhes. Para representar algum fenômeno ou parte do mundo, que nós chamamos
domínio, é necessário focar em um limitado número de conceitos que são suficientes e
relevantes para criar uma abstração do fenômeno à disposição. Assim, um aspecto central, de
qualquer atividade de modelagem consiste de desenvolver uma conceituação: um conjunto de
regras informais que confine a estrutura de uma parte da realidade, o qual um agente utiliza
para isolar e organizar objetos e relações relevantes. (BORST, 1997)
Muitos trabalhos sobre ontologias são encontrados na literatura e são apresentadas
diversas definições sobre o termo, no entanto, (BORST, 1997) apresenta uma definição
simples e completa: "Uma ontologia é uma especificação formal e explícita de uma
conceituação compartilhada". Nessa definição, "formal" significa legível para computadores;
"especificação explícita" diz respeito a conceitos, propriedades, relações, funções, restrições,
axiomas, explicitamente definidos; "compartilhado" quer dizer conhecimento consensual; e
"conceituação" diz respeito a um modelo abstrato de algum fenômeno do mundo real. A
conceituação é formada por um vocabulário controlado que é arranjado hierarquicamente e
através de relações entre conceitos, como nas taxonomias e tesauros. Uma conceituação é uma
visão abstrata e simplificada do mundo que se deseja representar.
21
2.2 Vantagens do uso de ontologias
Agora que já foi visto o que é uma ontologia, é importante que se destaque as
vantagens de seu uso. A seguir é apresentada uma lista com as principais vantagens da
utilização de ontologias na Ciência da Computação:
Ontologias fornecem um vocabulário para representação do conhecimento. Esse
vocabulário tem por trás uma conceituação que o sustenta, evitando assim interpretações
ambíguas desse vocabulário.
Ontologias permitem o compartilhamento de conhecimento. Sendo assim, caso exista
uma ontologia que modele adequadamente certo domínio de conhecimento, essa pode ser
compartilhada e usada por pessoas que desenvolvam aplicações dentro desse domínio. Para
exemplificar, considere que exista uma ontologia para o domínio de livrarias. Uma vez que
essa ontologia está disponível, várias livrarias podem construir seus catálogos usando o
vocabulário fornecido por essa ontologia sem a necessidade de refazer uma análise do
domínio de livraria.
Pode-se dizer, que fornece uma descrição exata do conhecimento. Diferentemente da
linguagem natural em que as palavras podem ter semântica totalmente diferente conforme o
seu contexto, a ontologia por ser escrita em linguagem formal, não deixa espaço para o gap
semântico existente na linguagem natural. Por exemplo, quando uma pessoa fala para outra a
palavra “Rede” ela pode estar querendo falar a respeito de uma rede de pesca, como também
de uma rede de computadores. A interpretação da palavra pode ser atribuída a um conceito ou
outro conforme o estado mental do indivíduo.
Porém, se há uma conceituação comum entre essas duas pessoas a possibilidade de
mal entendido diminui muito. Por exemplo, se essas pessoas concordam em uma ontologia
sobre o domínio de pesca, possivelmente não haverá mal entendido.
É possível fazer o mapeamento da linguagem da ontologia sem que com isso seja
alterada a sua conceituação, ou seja, uma mesma conceituação pode ser expressa em várias
línguas.
Pode ser possível estender o uso de uma ontologia genérica de forma a que ela se
adeqüe a um domínio específico. Por exemplo, se alguém precisa de uma ontologia sobre
bicicletas para construir uma aplicação e só encontra uma ontologia sobre o domínio genérico
de veículos, pode utilizar essa ontologia estendendo-a para o domínio específico da aplicação,
que no caso são de bicicletas.
22
Essas são as principais vantagens da utilização de ontologias. Existem muitas outras
vantagens, porém a maioria é decorrente dessas.
2.3 Composição
Os componentes básicos de uma ontologia são classes (organizadas em uma
taxonomia), relações (representam o tipo de interação entre os conceitos de um domínio),
axiomas (usados para modelar sentenças sempre verdadeiras) e instâncias (utilizadas para
representar elementos específicos, ou seja, os próprios dados). (GRUBER, 1996).
De forma resumida, uma ontologia é composta de: Domínio, Vocabulário, Glossário,
Tesauro, Taxonomia e Rede Semântica.
O domínio define a abrangência da ontologia. Como dito em (RUSSEL; NORVIG,
2004, p. 245), o domínio de uma representação do conhecimento é uma parte do mundo sobre
o qual se deseja expressar algum conhecimento. Este domínio define os limites onde é
definida toda a estrutura da ontologia.
O vocabulário é composto de classes e instâncias. As classes descrevem os conceitos
dentro do domínio considerado. Estes conceitos representam um conjunto abstrato de objetos.
Este conjunto considera características comuns entre estes objetos, sob um nível de abstração
específico, a fim de representar os objetos através de um conceito único.
As instâncias são as ocorrências particulares do objeto em relação à classe
considerada. Uma instância também descreve conceitos, mas de forma individualizada, única
e concreta, fazendo referência a um objeto real (documento, página de intranet, banco de
dados).
Ainda dentro dos vocabulários, as classes possuem características. Estas
características são definidas pelos seus atributos ou propriedades. Os atributos possuem valor
nas instâncias. As relações hierárquicas entre as classes compõem a taxonomia. Esta relação
define uma forma de estruturação onde classes pai possuem classes filhos, com atributos
herdados dos pais.
Finalmente, as regras desempenham um importante papel no enriquecimento
semântico de uma ontologia. As regras são assertivas lógicas que impõem restrições às suas
classes e aos atributos. Podem existir regras que proíbem, obrigam ou permitem valores de
atributos ou instâncias de uma classe, de acordo com a regra estabelecida e a condição da
regra satisfeita. Resumindo, uma ontologia é, estruturalmente, a representação de uma
23
determinada realidade, através de uma linguagem formal, composta de vocabulário,
relacionamentos e regras.
As taxonomias são compostas de termos ou conceitos sobre o universo da informação
armazenada relacionados de forma hierárquica. Do mesmo modo, o tesauro define conceitos,
mas permite também outros tipos de relacionamentos entre os conceitos. Utilizando
taxonomias ou tesauros, o usuário poderá escolher qual a categoria de informação ele deseja
acessar, podendo combiná-la com a busca por palavra chave. Este tipo de busca provê bons
resultados no acesso às informações. Sua deficiência é a não disponibilidade de uma
linguagem padrão que descreva a sua estrutura. Isso dificulta o compartilhamento desta
estrutura por outros sistemas, a construção de ferramentas de auxilio ao desenvolvimento das
estruturas e a utilização de sistemas de manipulação de regras de restrição.
2.4 Modelagem
As informações contidas em uma ontologia são modeladas através de classes, que são
os conceitos do domínio, sendo organizadas em hierarquias, definindo relacionamentos de
generalização (subclasses � superclasse) e especialização (superclasse � subclasse).
A Figura 2.1, ilustra um diagrama contendo a descrição básica de uma ontologia e
seus elementos básicos.
Figura 2.1: Representação hierárquica de uma ontologia
No entanto, somente as classes não fornecerão informação suficiente para responder
às perguntas da competência do escopo. Uma vez que definidas as classes, deve-se descrever
a estrutura interna dos conceitos. Para isso devem ser definidas também as propriedades
24
(atributos e relacionamentos), sendo que cada classe é caracterizada por um conjunto de
atributos e relacionamentos.
As propriedades de uma classe são herdadas por suas subclasses, portanto as
propriedades somente precisam ser definidas em um dos níveis da hierarquia.
A Figura 2.2 mostra a hierarquia de propriedades, onde, as propriedades são
especializadas em Propriedade Objeto e Propriedade de Tipo de Dados.
Figura 2.2: Hierarquia de propriedades
Uma propriedade é declarada como Propriedade Objeto quando tem o papel de
relacionar uma classe à outra classe.
A Propriedade de Tipo de Dados se diferencia da Propriedade Objeto por utilizar uma
variável para representar qualquer coisa no domínio abordado. Neste tipo de propriedade,
também é necessário definir o domínio a qual ela pertence e o seu valor que, não mais será
uma classe, mas um elemento do tipo string, boolean, int, entre outros.
Além disso, as Propriedades Objeto são especializadas em Simétrica, Transitiva,
Funcional e Inversa, que são definidas a seguir.
Propriedade Simétrica: Uma propriedade R é simétrica quando, se x se relaciona
com y, y se relaciona com x, assim: se para cada x, y ∈ E; R(x,y) implica R(y, x), conforme
ilustra a Figura 2.3.
25
Figura 2.3: Propriedade Simétrica
Propriedade Transitiva: Uma propriedade R é transitiva quando, se x está
relacionado com y e y está relacionado com z, então x se relaciona com z, assim: se, para cada
x, y, z ∈ E; existe R(x, y) e R (y, z) implica R(x, z), conforme ilustra a Figura 2.4.
Figura 2.4: Propriedade Transitiva
Propriedade Funcional: Uma propriedade funcional é aquela em que se tem um
único valor de y para cada instância de x. Portanto, não tem mais do que um único valor para
cada indivíduo. Uma propriedade com esta característica é dita ter cardinalidade mínima 0 e
cardinalidade máxima 1, assim: se, para cada x ∈ W, existe um único y ∈ W tal que R(x, y),
conforme ilustra a Figura 2.5.
Figura 2.5: Propriedade Funcional
Em OWL, a owl:FunctionalProperty é uma subclasse de owl:DatatypeProperty e
também é uma subclasse de owl:ObjectProperty (BECHHOFER et al , 2004).
As propriedades podem ser ditas funcionais inversas. Se uma propriedade é funcional
inversa, então, o inverso da propriedade é funcional (HARMELEN; MCGUINNESS, 2004).
Deste modo, o inverso da propriedade tem, no máximo, um valor para cada indivíduo.
26
Propriedade Inversa: As propriedades tem um sentido, no caso da inversa, este
sentido pode ser dado de ambos os lados, assim para cada par P1(x,y) existe um inverso P2(y,
x) e vice-versa.
As propriedades também podem possuir subpropriedades, possuir relações de
equivalência e serem reflexivas.
Propriedade Reflexiva: Quando todo elemento de E se relaciona com ele mesmo,
assim: se, para cada x ∈ E, existe R(x,x) em E, conforme ilustra a Figura 2.6.
Figura 2.6: Propriedade Reflexiva
Propriedade Equivalente: Uma propriedade é equivalente se possuir as
propriedades reflexiva, transitiva e simétrica, conforme ilustra a Figura 2.7.
Figura 2.7: Propriedade Equivalente
27
Existem outras propriedades interessantes: Anti-simétrica, Irreflexiva, Assimétrica
e Intransitiva. Elas aparecem em outras áreas da ciência, mas não abrange o escopo deste
trabalho.
Cada propriedade é modelada por um conjunto de restrições que definem os valores
que podem ser assumidos, os quais descrevem ou limitam o conjunto de valores possíveis
para uma propriedade.
As restrições (facetas) mais comuns são a cardinalidade do valor da propriedade seus
limites, strings, números, elemento de um conjunto, etc.
Em OWL as restrições podem ser de valores (allValuesFrom, someValuesFrom e
hasValue), de cardinalidade (maxCardinality, minCardinality e cardinality), de intersecção
(intersectionOf), de união (unionOf) e de enumeração (enumeration.) A Figura 2.8 ilustra
exemplos de restrições definidos em OWL.
Figura 2.8: Definição de restrições em OWL, no ambiente Protegé.
As instâncias são entidades do domínio que atendem às especificações de uma classe.
A atividade de instanciação corresponde a criar os registros de uma base de dados a partir do
seu esquema (descrição das classes).
2.4.1 Restrição de valor
A seguir são detalhadas as principais restrições de valores, utilizadas em OWL.
AllValuesFrom: A restrição allValuesFrom é declarada em uma propriedade com
respeito a uma classe, isto é, a restrição requer que, para cada instância da classe que tenha
instâncias da propriedade especificada, os valores da propriedade devem ser todos os
28
membros da classe indicada pela cláusula allValuesFrom. (SMITH; WELTY;
MCGUINNESS, 2004)
SomeValuesFrom: A restrição someValuesFrom descreve a classe de indivíduos x
para os quais existe pelo menos um y, tal que o par (x, y) seja uma instância da propriedade,
isto é, a restrição requer que, pelo menos para uma instância da classe que tenha instâncias da
propriedade especificada, os valores da propriedade devem ser membros da classe indicada
pela cláusula someValuesFrom. (SMITH; WELTY; MCGUINNESS, 2004)
HasValue: A propriedade hasvalue permite que uma propriedade tenha um certo
indivíduo como valor. Em outras palavras, hasvalue permite especificar classes baseadas na
existência de valores de propriedades particulares, assim, um indivíduo será membro de tal
classe sempre que pelo menos um dos valores das propriedades for igual ao valor do recurso
hasvalue. (SMITH; WELTY; MCGUINNESS, 2004)
2.4.2 Restrições de cardinalidade
A OWL permite utilizar restrições de cardinalidade, uma vez que qualquer instância
de uma classe pode ter um número arbitrário de valores para uma propriedade. As restrições
de cardinalidade são restrições locais, uma vez que elas são declaradas em propriedades com
respeito a uma classe. Segundo (BECHHOFER et al , 2004), a OWL provê três construções
para cardinalidade:
• owl:maxCardinality: descreve uma classe de todos os indivíduos que têm, no
máximo, N valores semanticamente distintos.
• owl:minCardinality: descreve uma classe de todos os indivíduos que têm, no
mínimo, N valores semanticamente distintos. Esta restrição é um meio para dizer que uma
propriedade é requerida ter um valor para todas as instâncias da classe.
• owl:cardinality: descreve uma classe de todos os indivíduos que têm exatamente N
valores semanticamente distintos.
Para estas cardinalidades, a Figura 2.9 mostra um exemplo da classe concreta que
possui no mínimo uma instância associada e no máximo N instâncias associadas.
29
Figura 2.9: Cardinalidade da Classe Concreta
É importante ressaltar que, antes de se construir uma restrição, deve-se definir uma
classe para armazenar todas as instâncias referentes ao mesmo.
Observa-se que a restrição é uma forma de resposta às questões que são de
competência da ontologia. Uma classe complexa formada a partir de equivalências, ou dos
quantificadores universal e existencial, é a representação em OWL das verdades do domínio,
ou seja, das suas restrições. A Figura 2.10, ilustra um exemplo de definição de restrição
desenvolvida no ambiente Protegé, onde para todo termo existe no mínimo um conceito
associado.
Figura 2.10: Definição da restrição Termo juntamente com a classe e condição necessária, no Protegé
Restrições também podem ser utilizadas para representar o “ou” exclusivo (xor),
quando instâncias de duas ou mais classes podem se relacionar com instâncias de uma outra
classe específica.
As restrições podem ainda ser utilizadas para definir melhor a semântica de classes
especializadas derivadas de classes gerais. As restrições pré-definidas para classes
especializadas são:
Completa: quando todas as sub-classes possíveis foram derivadas da classe geral;
Incompleta: quando ainda é possível derivar novas sub-classes.
30
Separada ou Disjunta: quando as subclasses são mutuamente exclusivas, ou seja, no
momento que uma instância pertence a uma sub-classe, não poderá de forma alguma
pertencer a qualquer das outras subclasses derivadas.
Sobreposta: quando o fato de pertencer a uma sub-classe não impede que pertença a
outras.
Definir instâncias: As instâncias são entidades do domínio que atendem às
especificações de uma classe. A atividade de instanciação corresponde a criar os registros de
uma base de dados a partir do seu esquema (descrição das classes).
2.4.3 Representação das instâncias
Em uma ontologia todos os elementos que são representados pode ser instanciados.
A Figura 2.11 apresenta um exemplo da instanciação da Classe Termo, que é
nomeado por um conceito x , que seria a própria definição da palavra termo. Os termos são
representados por Classes e podem se relacionar com outros termos através de propriedades.
Figura 2.11: Exemplo de Instanciação da Classe Termo
31
2.5 Considerações do Capítulo
Este capítulo teve por objetivo dar uma breve introdução aos conceitos de ontologias,
relacionar algumas vantagens de seu uso, assim como demonstrar os componentes básicos
que são necessários para modelagem de uma ontologia.
A partir disso, foram estudadas as formas de representação das ontologias,
demonstradas no capítulo a seguir.
32
3. Representação de Ontologias
A fase final no desenvolvimento de uma ontologia é realizada por meio de uma
representação específica que permite o processamento e a abrangência do conhecimento pela
máquina.
Isso é possível através de uma linguagem específica para a criação de ontologias e de
uma ferramenta que permita sistematizar e integrar as especificações definidas à linguagem
utilizada.
Constantemente novas linguagens para a definição de ontologia são desenvolvidas,
dentre essas linguagens podem ser citadas: OIL (OIL, 2000), XOL (XOL, 1999), DAML+OIL
(DAML+OIL, 2001), OWL (SMITH, 2003). Todas essas linguagens, apesar de suas
particularidades, possuem uma característica comum: a capacidade de representar ontologias
em RDF e RDF Schema. Para tanto, é feita uma breve explanação a respeito dos conceitos
XML, RDF/RDF Schema e OWL nas seções subseqüentes. A Figura 3.1 ilustra um exemplo
de modelo em camadas.
Figura 3.1: O modelo em camada para as linguagens de ontologias.
Neste capítulo são apresentadas as de formas de representação de ontologias mais
comumente utilizadas, como o padrão XML, RDF e OWL; os grafos e matrizes de
adjacências e a representação contextual.
3.1 Padrão XML, RDF e OWL
A seguir uma breve descrição dos padrões para representação de ontologias XML,
RDF e OWL.
33
3.1.1 XML
A XML foi criada para permitir o desenvolvimento de documentos em formatos
próprios. Assim como documentos em HTML, documentos XML contém texto.
Esse texto contém primeiramente o conteúdo em si do documento e linguagem de
marcação na forma de tags. Essa marcação permite um programa processador interpretar as
diversas partes do conteúdo como "elementos". Tanto o conteúdo do documento XML como
as tags (com algumas exceções) podem conter caracteres Unicode, permitindo que
informações de diversas linguagens sejam representadas diretamente.
Em HTML, o conjunto de tags permitidas e a respectiva interpretação é definida pela
especificação HTML. A linguagem XML permite a seus usuários definir suas próprias
linguagens de marcação (tags e as estruturas nas quais elas podem aparecer) adaptadas para
seus próprios requisitos específicos (a linguagem RDF/XML é uma linguagem de marcação
XML).
Desta forma, a formatação do documento é tratada separadamente de sua estrutura,
resolvendo assim um dos principais problemas do HTML, sem incorrer em um sistema de
marcações complexas como a SGML (MOURA, 2001).
A linguagem XML deve respeitar duas restrições: tags devem estar corretamente
aninhadas e atributos devem ser únicos. Quando um documento atende a essas duas restrições
diz-se que um documento é bem formado, sendo possível organizá-lo segundo uma estrutura
de árvore e representá-lo via XML na web, o que auxilia na recuperação da informação. O
Quadro 3.1 demonstra um exemplo de código XML.
34
Quadro 3.1: Exemplo de código XML. Retirado de (ANTONIOU; VAN HARMELEN, 2004)
3.1.2 RDF
RDF é uma recomendação da W3C (World Wide Web Consortion) que apresenta uma
nova forma de descrição dos dados na web. Para que o modelo de dados RDF possa ser
representado, foi adotado o conceito de metadados (LASSILA, 1999), de forma a possibilitar
a descrição de recursos e, com isso, propiciar uma semântica aos mesmos.
Esse modelo teve grande aceitação dentre as ferramentas que proporcionam a
resolução da interoperabilidade em diversas plataformas devido a sua arquitetura genérica de
metadados, permitindo, assim, a descrição dos recursos no contexto web através de padrões de
metadados (LASSILA, 1999).
O modelo RDF encontra-se definido em dois documentos: Resource Description
Framework (RDF) Model and Syntax Specification (LASSILA, 1999), que descreve o
modelo de dados RDF e Resource Description Framework (RDF) Schema Specification
(BRICKLEY, 2000), que descreve as primitivas de modelagem utilizadas para a descrição de
um domínio particular de interesse.
A estrutura de uma expressão em RDF é uma coleção de triplas, cada uma
consistindo de um sujeito, predicado e objeto. O conjunto dessas triplas é chamado de grafo
RDF. Isso pode ser ilustrado por um nó e um arco-direcionado no diagrama, onde cada tripla
é representada por um nó-arco-nó. Cada tripla representa uma declaração de relacionamento
35
entre as coisas denotadas pelos nós ligados pelo arco. Cada tripla tem três partes, conforme
Figura 3.2:
1. Sujeito.
2. Objeto.
3. Predicado (propriedade) que denota um relacionamento.
Figura 3.2: Grafo RDF representando uma tripla.
O RDF destaca-se pela simplicidade com que busca estruturar o conteúdo contido na
web. Ele não é uma linguagem, mas sim um modelo de representação para descrição
semântica de recursos.
Para a serialização desse modelo foi adotada, pela W3C, a linguagem XML, pois a
mesma demonstra algumas facilidades. Dentre elas destaca-se: a facilidade de estruturação
dos documentos, pois os elementos que compõem os documentos XML podem ser criados de
acordo com a necessidade. O quadro 3.2 demonstra um exemplo de trecho de código RDF.
Quadro 3.2: Trecho de código RDF.
3.1.3 OWL
A linguagem OWL apresenta mais facilidades para expressar significados e
semânticas do que XML, RDF e RDF Schema, embora seja baseada em RDF e RDF Schema
e utilize a sintaxe XML.
36
Conforme [OWL, 2004] resume, a OWL é projetada para aplicações que precisam
processar informação e não apenas apresentar essa informação para humanos. Ela facilita
enormemente a interpretabilidade da máquina acerca de conteúdo Web, muito mais do que
XML, RDF ou mesmo RDFS são capazes de fornecer, pois fornece vocabulário adicional e
uma semântica formal.
Foi desenvolvida baseando-se nas linguagens DAML e OIL e construída em cima da
arquitetura XML e RDF. A OWL foi proposta como padrão pelo W3C3, agregando diversos
pontos positivos das linguagens anteriores, e está sendo utilizada pela WEB Semântica.
Além disso, a OWL é a mais promissora e sofisticada que suas linguagens bases
porque, por exemplo, seus conceitos podem ser especificados por combinações lógicas como
interseção, união, ou complementos de outros conceitos, ou por enumerações de objetos
especiais. OWL pode indicar que uma propriedade é transitiva, simétrica, funcional ou
inversa, em relação à outra propriedade, quais indivíduos, i.e., instâncias, pertencem à quais
conceitos, que conceitos e propriedades podem usar indicações de equivalência e disjunção,
que indicações de igualdade e diferença podem ser utilizadas entre indivíduos, entre outras
informações fundamentais para fornecer o suporte semântico necessário para os primeiros
passos da Web Semântica.
A linguagem OWL é baseada na Lógica de Descrições, havendo uma
correspondência entre as linguagens XML para expressar ontologias e uma lógica de
descrição. Foram definidas três sub-linguagens OWL cada uma correspondendo a uma lógica
de descrição (OWL Lite, DL e Full).
• OWL Lite - sua finalidade principal é dar suporte para que classificações
hierárquicas com restrições simples sejam criadas. Por exemplo, restrições de cardinalidade
são permitidas para apenas valores iguais a zero ou um. Assim, OWL Lite é própria para a
construção de axionomias e tesauros.
• OWL DL - sua finalidade é prover um maior grau de expressividade onde todas as
conclusões são computáveis (completude) e todas as computações terminam em tempo finito
(decidíveis). OWL DL corresponde a Description Logic (BAADER et al, 2003).
37
• OWL Full - sua finalidade é prover o máximo de expressividade e liberdade
sintática. Com OWL Full, os usuários podem aumentar o vocabulário pré-definido de RDF ou
OWL, porém sem nenhuma garantia computacional.
OWL Full pode ser visto como uma extensão ao RDF, ao passo que OWL Lite e
OWL DL seriam extensões a visões restritas do RDF. Todo documento OWL é um
documento RDF e todo documento RDF é um documento OWL Full.
No entanto, nem todo documento RDF é um documento OWL Lite ou OWL DL (pois
estas linguagens são mais restritas). Por essa razão, deve haver um certo cuidado na hora de
migrar documentos RDF para OWL Lite ou OWL DL.
Algumas das restrições são: toda URI que é usada como nome de uma classe deve
explicitamente ter o tipo owl:Class (e de maneira similar para as propriedades), todo
indivíduo deve explicitamente pertencer a no mínimo uma classe (mesmo que seja
owl:Thing), as URIs usadas para classes, propriedades e indivíduos devem ser mutuamente
disjuntas.
A estrutura encontrada em um arquivo OWL possui elementos característicos, alguns
desses elementos são descritos a seguir (W3C, 2004):
• Versão e Namespaces: necessários para indicar que vocabulários específicos
estão sendo utilizados na ontologia. O quadro 3.3 ilustra a declaração de versão e
namespace em OWL.
Quadro 3.3: Parte de código OWL representando a versão e namespaces
Os elementos em destaque, no quadro 3.4, identificam versão e namespaces da
ontologia. Namespaces são identificadores únicos dos elementos, atuam como um
qualificador para um conjunto específico de nomes. As informações prefixadas com OWL
referem-se a itens definidos em uma namespace.
38
Após os elementos que formam a estrutura inicial do documento OWL, têm-se a
representação das classes, subclasses, instâncias e atributos. Considerando-se que os atributos
são divididos, na ontologia, em dois tipos: Datatype property, associa indivíduos a valores de
dados, e Object Property, associa indivíduos a outros indivíduos. Sendo alguns desses
elementos ilustrados no quadro 3.4.
Quadro 3.4: Parte de código OWL representando alguns elementos que formam a estrutura inicial de um documento OWL.
3.2 Grafos e Matrizes de Adjacência
Os grafos e matrizes de adjacência são recursos muito utilizados para visualizar a
representação de uma ontologia.
Neste trabalho, para estruturação dos algoritmos foram utilizadas matrizes de
adjacência que são representações de grafos valorados.
A gramática de grafos é um formalismo de especificação na qual os estados de um
sistema são representados por grafos e as transições são especificadas por regras. Neste
formalismo os estados de um sistema são descritos através de estruturas algébricas (grafos
que podem ou não ter atributos especificados como tipos de dados abstratos) e o
comportamento do sistema é determinado operacionalmente por mudanças de estado.
39
Os grafos são meios naturais para explicar situações complexas em um nível
intuitivo. A idéia básica da gramática de grafos é análoga à da gramática de Chomsky. A
noção resultante da gramática de grafos generaliza a da gramática de Chomsky. A
composição da gramática de grafos parte de um Grafo Tipo e de um Grafo Inicial. Um Grafo
Tipo descreve as possíveis ocorrências em um grafo. É uma forma simplificada, porém
bastante representativa e significativa que substitui um provável grande conjunto de regras
que controlariam o grafo. Um Grafo Inicial apresenta a primeira instância do grafo, nela está
representado o estado inicial do sistema aguardando a aplicação de regras que o
transformarão. (RUSSI; SILVA, 2008)
Uma matriz de adjacências é uma das formas de se representar um grafo.
Dado um grafo G com n vértices podemos representá-lo em uma matriz n x n M. A
definição precisa das entradas da matriz varia de acordo com as propriedades do grafo que se
deseja representar, porém de forma geral o valor mij guarda informações sobre como os
vértices vi e vj estão relacionados (isto é, informações sobre a adjacência de vi e vj).
As figuras 3.3 e 3.4 são exemplos de grafos representados através da matriz de
adjacência correspondente.
Figura 3.3: Duas representações de um grafo orientado. a) um grafo orientado G que tem 4 vértices e 4 arestas. b) uma representação de G como matriz de adjacências.
40
Figura 3.4: Duas representações de um grafo orientado. a) um grafo orientado G que tem 3 vértices e 3 arestas. b) uma representação de G como matriz de adjacências.
Fazendo-se a soma para um mesmo relacionamento dos dois grafos, obtemos um
grafo contendo as 2 representações, conforme figura 3.5.
Figura 3.5: Representações de um grafo orientado. a) um grafo orientado G que tem 3 vértices e 3 arestas. b) uma representação de G como matriz de adjacências.
Para representar um grafo não direcionado simples e sem pesos nas arestas, basta que
as entradas mij da matriz M contenham 1 se vi e vj são adjacentes e 0 caso contrário. Se as
arestas do grafo tiverem pesos, mij pode conter, ao invés de 1 quando houver uma aresta entre
vi e vj, o peso dessa mesma aresta.
Uma das características da matriz de adjacência quando o grafo não é orientado é a
simetria encontrada na "diagonal". É interessante que se lermos uma coluna de índice v ou
uma linha de índice v vamos encontrar a mesma coisa.
41
3.2.1 Principais Vantagens da Utilização de Gramática de Grafos
A seguir, serão apresentadas, aquelas que atualmente, são consideradas as principais
vantagens na utilização da Gramática de Grafos no desenvolvimento de sistemas:
Representação dos Dados: Grafos provêm uma representação de dados expressiva e
versátil de um sistema. Do ponto de vista da interação entre o usuário e o modelo do sistema
pode-se observar que os grafos podem ser, até certo ponto, intuitivos e, em geral, de fácil
compreensão por parte dos usuários. A rescrita de grafos também possui a característica de
proporcionar uma representação de alto nível da solução de um problema computacional,
qualquer que este seja.
Rescrita de Grafos: Seguindo o tema anterior, outra vantagem da modelagem de um
sistema através da rescrita de grafos é a possibilidade de simulação (com o auxílio de
ferramentas) o que proporciona além de sua verificação formal, a validação do sistema, ou
seja, a avaliação de sua conformidade com os requisitos funcionais.
Incremento na Qualidade e Produtividade: Também, as gramáticas de grafos
proporcionam grande incremento na qualidade e produtividade na fase de manutenção de um
sistema, em função da total previsibilidade do comportamento de um sistema em caso de
alteração em seus requisitos. Esse fator é de grande importância se for considerado que a
manutenção representa 60% da vida útil de um sistema.
Utilidade na Modelagem de Sistemas: A utilização de gramática de grafos como
método para a modelagem de sistemas, pela sua flexibilidade e representação, pode ser uma
poderosa ferramenta de modelagem de diversos aspectos a serem representados durante o
desenvolvimento.
3.3 Representação contextual
A representação contextual consiste em representar Ontologias (Oi , O2 ... On), onde
Oi (para i=1, 2, ...n) é caracterizada por um par (Ci, Ri), sendo que Ci é um conjunto de
conceitos e Ri é um conjunto de relacionamentos sobre Ci.
A figura 3.6 demonstra um exemplo de uma ontologia representado através de matriz
de adjacências, contendo as classes e seus respectivos relacionamentos.
42
Figura 3.6: Matriz de Adjacências representando conceitos e relacionamentos.
Sendo que os elementos de cada Ri são todos triplas (A, B, P), onde A, B ∈ Ci (são
conceitos) e P nomeia uma lista de relacionamento(s) específico(s) entre eles, nesta ordem.
Eventualmente usa-se (A, _, P) se P é um atributo do conceito A (localizado na
diagonal principal da matriz de adjacência correspondente).
A figura 3.7 demonstra a seqüência de processos para a conversão das ontologias:
• Partindo do código OWL inicial das ontologias que se deseja integrar (triplas)
produz-se as matrizes de adjacência (MA) iniciais.
• Estas são operadas por um operador, produzindo a MA resultante, que é então
convertida no código OWL final resultante.
Figura 3.7: Seqüência de passos do processo de conversão de ontologias
É importante ressaltar que “op” pode ser qualquer operador utilizado. Por exemplo,
pode-se usar a intersecção para obter apenas a parte comum de um conjunto de ontologias, a
união de 2 ou mais ontologias, a diferença, dentre outras opções.
A figura 3.8 demonstra a estratégia utilizada neste trabalho, para fazer a
interoperabilidade entre ontologias, utilizando o parser Thea para conversão de ontologias no
formato OWL em matriz de adjacências. Então é aplicado o operador relacional e
posteriormente, é gerado uma matriz de adjacências, sendo o resultado uma ontologia única
em formato OWL.
43
Para conversão da Matriz de adjacências em código OWL, foi desenvolvido um
código em Prolog que insere o predicado triplas, detalhado no capítulo 4.3.
Figura 3.8: Estratégia para a integração de ontologias
3.4 Considerações do capítulo
Este capítulo objetivou demonstrar as formas de representar uma ontologia.
Inicialmente foram abordadas as linguagens XML, RDF e OWL que se constituem em formas
mais popularmente utilizadas. Os grafos e matrizes de adjacências foram estudados com o
intuito de demonstrar a representação visual de uma ontologia, servindo também, de base para
a representação contextual de uma ontologia.
No próximo capítulo serão apresentados os aspectos relacionados à interoperabilidade
entre ontologias.
Primeira ontologia no formato OWL Segunda ontologia no formato OWL
Conversão de OWL para matriz através do Parser Thea
Primeira ontologia no formato OWL convertida
Segunda ontologia no formato OWL convertida
Aplicação do operador
Primeira e segunda ontologia integradas no formato OWL
Geração da Matriz de Adjacências e conversão em OWL
44
4. Interoperabilidade entre ontologias
Neste capítulo são apresentados assuntos relacionados à interoperabilidade entre
ontologias, como os mecanismos encontrados na literatura; a conciliação de vocabulários
utilizando os padrões Dublin Core e FOAF; as ferramentas e métodos de conversão
empregados para converter ontologias OWL em formato de triplas e vice-versa e os
operadores relacionados, assim como os algoritmos desenvolvidos neste trabalho. Ao final, é
demonstrado um exemplo de interoperabilidade dinâmica entre ontologias aplicadas ao
domínio de um congresso.
4.1 Mecanismos de Interoperabilidade
De forma geral, as ontologias têm como objetivo promover um entendimento comum
e compartilhado sobre um domínio, que pode ser comunicado entre pessoas e sistemas de
aplicação (BISHR, 1997). No entanto para que trabalhem em conjunto, trocando
automaticamente as informações representadas em ontologias, são necessários mecanismos
que garantam a sua interoperabilidade.
Abaixo são destacados alguns mecanismos que podem ser usados para propiciar a
compatibilidade de ontologias:
Combinação de ontologias: tem-se como resultado a versão das ontologias originais
combinadas em uma ontologia única com todos seus termos juntos, sem a definição clara de
suas origens. Normalmente as ontologias originais descrevem domínios similares ou de
sobreposição. (NOY; MUSEN; SMART, 1999).
A figura 4.1 , ilustra um exemplo de combinação de ontologias, onde os dois
conceitos compatíveis, por exemplo carro da ontologia O1 e veículo da ontologia O2,
poderiam ser combinados, i.e., unidos, gerando uma ontologia única O3.
45
Figura 4.1: Exemplo do mecanismo de combinação de ontologias
Integração de ontologias: tem-se como resultado uma ontologia única criada pela
montagem, extensão, especialização ou adaptação de outras ontologias que tratam não
necessariamente do mesmo assunto. Na integração de ontologias é possível identificar as
regiões que foram criadas a partir das ontologias originais. (PINTO; GOMEZ-PEREZ;
MARTINS, 1999).
A figura 4.2 ilustra um exemplo de integração de ontologias, onde os conceitos carro
de O1, veículo de O2 e casa de O3 são integrados, i.e., unidos, na ontologia única O.
Figura 4.2: Exemplo do mecanismo de integração de ontologias
Apesar do resultado final, tanto da combinação quanto da integração de ontologias ser
uma ontologia única constituída pela união dos termos das ontologias originais, a principal
diferença entre estes dois mecanismos é que no primeiro as ontologias tratam do mesmo
assunto, o que não acontece necessariamente no segundo.
46
Alinhamento de ontologias: tem-se como resultado as duas ontologias originais
separadas, mas com as ligações estabelecidas entre elas, permitindo que as ontologias
alinhadas reusem as informações uma das outras. O alinhamento normalmente é realizado
quando as ontologias são de domínios complementares. (NOY; MUSEN; SMART, 1999)
A figura 4.3 ilustra um exemplo de alinhamento de ontologias, onde a ontologia O1
se refere a carros, a ontologia O2 se refere a veículos e a O3 a meios de transporte.
Figura 4.3: Exemplo do mecanismo de alinhamento de ontologias.
Mapeamento de ontologias: tem-se como resultado uma estrutura formal que
contém expressões que fazem a ligação de conceitos de um modelo em conceitos de um
segundo modelo. Este mapeamento pode ser usado para transferir instâncias de dados,
esquemas de integração, esquemas de combinação e tarefas similares. (NOY; MUSEN;
SMART, 1999)
A figura 4.4, ilustra um exemplo de mapeamento de ontologias, onde os conceitos
carro de O1 e veículo de O2 são mapeados em expressões formais.
Figura 4.4: Exemplo do mecanismo de mapeamento de ontologias
47
Todos estes mecanismos podem ser realizados, em uma ontologia, de forma
automática, semi-automática, onde há a necessidade de intervenção humana em algumas
etapas para a tomada de decisão, ou até mesmo manual.
4.1.1 A aplicação dos mecanismos
Os mecanismos de interoperabilidade citados acima podem ser aplicados em um
ambiente de agentes orientado por ontologias.
Considerando dois agentes colaborativos A e B modelados através de uma ontologia
A e B, que possuem suas classes, propriedades, restrições e instâncias. Cada classe possui
uma definição associada, assim como os termos sinônimos, sendo os mesmos definidos em
um glossário de termos do domínio em questão.
No mecanismo de combinação de ontologias para que seja possível efetuar a troca de
conhecimentos, dois agentes com domínios similares1 ou de sobreposição2, interagem
formando uma única ontologia. No caso, um agente colaborador A com conhecimentos de
enfermagem e um agente colaborador B com conhecimentos de Medicina, cada um tem na
sua ontologia os conhecimentos específicos de sua área, no momento que eles interagirem
para trocarem informações será formada uma única ontologia com as informações que as suas
área possuem em comum, demonstrado na figura 4.5.
Figura 4.5: Exemplo de combinação de ontologias 1 Neste trabalho, entende-se por domínios similares aqueles domínios que tratam do mesmo assunto. 2 Neste trabalho, entende-se que um domínio A qualquer é de sobreposição a um domínio B qualquer, quando A além de possuir as informações contidas em B também possui informações adicionais sobre o mesmo assunto de B.
48
No exemplo, a classe paciente possui a propriedade prescrição, que é definida como
propriedade objeto, justamente por ser comuns as áreas de medicina e enfermagem, podendo
se relacionar e formar uma única ontologia. As demais propriedades são definidas como
propriedade de tipo de dados.
No mecanismo de integração de ontologias para que seja possível efetuar a troca de
conhecimentos, dois agentes de domínios diferentes são integrados e formam uma única
ontologia. Neste caso um agente colaborador A com conhecimentos de Medicina e outro
agente colaborador B com conhecimentos de Música, por exemplo, quando interagirem irão
formar uma única ontologia contendo todos os dados das duas ontologias, ou seja, será feita
uma união das ontologias, demonstrado na figura 4.6.
Figura 4.6: Exemplo de integração de ontologias
Para o mecanismo de mapeamento de ontologias, devem ser mapeadas as relações,
instâncias de dados, esquemas de integração e tarefas similares, tendo como resultado uma
estrutura formal com expressões que ligam os termos de uma ontologia nos termos de outra
ontologia. Como demonstração de exemplo poderíamos ter um agente colaborador A com
conhecimentos de carro e um agente colaborador B com conhecimentos de veículos,
conforme figura 4.7.
49
Figura 4.7: Exemplo de mapeamento de ontologias
O mecanismo de alinhamento de ontologias, acontece quando os domínios das
ontologias são complementares3, sendo que são geradas duas ontologias separadas mas com
as ligações estabelecidas entre elas. Seria o caso de um agente colaborador A com
conhecimentos específicos de comidas e outro agente colaborador B com conhecimentos de
bebidas, ambos pertencem ao ramo da alimentação e quando feito o alinhamento haverão
propriedades que serão complementares, ou seja, será feita uma intersecção das ontologias,
conforme figura 4.8.
Figura 4.8: Exemplo de alinhamento de ontologias
3 Neste trabalho, entende-se que um domínio A qualquer é complementar a um domínio B qualquer, quando A adiciona informações a B. Normalmente, domínios complementares tratam de assuntos diferentes, mas suas partes comuns tratam de um mesmo assunto.
50
No exemplo o agente colaborador A possui conhecimentos específicos de comidas
em geral, enquanto o agente colaborador B é especializado em vinhos, no entanto, ambos
pertencem ao ramo da alimentação, quando alinhados suas ontologias se complementarão.
Neste trabalho buscou-se a utilização de operadores relacionais na construção dos
algoritmos, sendo que a operação de união é considerada a “chave” para as demais, onde a
partir dela poderão ser utilizados os operadores de intersecção e diferença. Por estas razões, os
mecanismos de combinação e integração de ontologias foram os escolhidos.
4.2 Conciliação de vocabulários
O estabelecimento de padrões para definição de vocabulários são essências ao
intercâmbio de informações.
Neste trabalho foram utilizados os padrões Dublin Core e o FOAF por serem
considerados padrões de metadados muito utilizados atualmente, de consenso internacional,
estudados pela W3C (W3C, 2008) e que incluem os aspectos de precisão, fidelidade, critérios
de seleção, generalizações, consistência dos dados, definições utilizadas e metadados sobre as
fontes de dados.
4.2.1 Dublin Core
O (DC, 2008) é um padrão da organização DCMI (Dublin Core Metadata Initiative)
para representação de metadados que especializados em representar informações dos dados
(dados sobre dados), possui um formato simples e muito útil para identificar o conteúdo dos
documentos eletrônicos, tornando-os mais fáceis de serem pesquisados pelos mecanismos de
buscas, a fim de recuperar as informações solicitadas.
É um padrão de metadados, composto por 15 elementos, planejado para facilitar a
descrição de recursos eletrônicos. Conforme (SOUZA, VENDRUSCULO, MELO, 2000)
destacam que as principais características deste padrão são a simplicidade na descrição dos
recursos, o entendimento semântico universal (dos elementos), o escopo internacional e a
extensibilidade (o que permite adaptações às necessidades adicionais de descrição).
O DC pode ser inserido em uma página HTML (Hypertext Markup Language) e
utiliza a linguagem XML (eXtensible Markup Language). Adota a sintaxe do RDF (Resource
51
Description Framework), possui um conjunto de 15 elementos básicos, apresentados na tabela
1, que podem ser implementados livremente para atender as necessidades de cada usuário
(DC, 2008), e, ainda é um formato padrão adotado para efetuar a interoperabilidade entre
outros formatos.
A tabela 4.1, descreve os 15 elementos do Dublin Core e suas respectivas descrições.
Tabela 4.1: Elementos do Dublin Core
Elementos Descrição
1. Título Título será o nome pelo qual o recurso é formalmente conhecido.
2. Criador Criador inclui uma pessoa, uma organização, ou um serviço. Tipicamente, o nome de um Creator deve ser usado para indicar uma entidade responsável pela existência do recurso.
3. Assunto Assunto deverá ser expresso por palavras chave, frases, ou códigos de classificação que descrevem o conteúdo do recurso.
4. Descrição Descrições podem incluir, sem estarem limitadas a um conteúdo do recurso: um resumo, um índice, uma referência a uma representação gráfica do conteúdo, ou uma descrição textual.
5. Publicador Editor pode ser uma pessoa, uma organização ou um serviço. Tipicamente, o nome de um Editor deve ser usado para indicar a entidade.
6. Contribuidor Contribuinte inclui uma pessoa, organização ou serviço. Tipicamente, o nome de outro Contribuinte deve ser usado para indicar a entidade.
7. Data Uma Data deve ser associada à criação ou disponibilidade do recurso. Como boa prática recomenda-se o formato AAAA-MM-DD.
8. Tipo Tipos incluem termos descrevendo categorias genéricas, funções, gêneros, ou níveis de agregação para o conteúdo. Ex: vocabulários.
9. Formato Formato deve incluir o tipo de meio do recurso, ou as suas dimensões. Este elemento deve ser usado para determinar as aplicações informáticas ou qualquer tipo de equipamento necessário para reproduzir ou operar com o recurso.
10. Identificador Identificação do recurso por meio de uma cadeia de caracteres ou por um número de acordo com um sistema de identificação formal.
11. Origem O presente recurso pode ter derivado do recurso Fonte na sua totalidade ou apenas em parte. Como boa prática recomenda-se a referência ao recurso fonte através de um identificador em conformidade com um sistema de identificação formal.
12. Linguagem A língua do conteúdo intelectual do recurso. Por exemplo, 'en' para Inglês, 'fr' Francês, ou 'en-uk' para o Inglês do Reino Unido.
13. Relação Uma referência a um recurso relacionado.
14. Abrangência Cobertura inclui tipicamente uma localização espacial (o nome de um lugar ou coordenadas geográficas), um período no tempo (a sua designação, data, ou intervalo de tempo), ou jurisdição (o nome de uma entidade administrativa).
15. Direitos Direitos sobre o recurso, ou uma referência a um serviço que fornecerá essa informação.
52
4.2.2 FOAF (Friend Of A Friend)
O projeto do FOAF tem por objetivo descrever as pessoas, as relações entre eles e as
coisas que elas criam e fazem.
Os termos do FOAF (FOAF, 2008) são agrupados em várias categorias, dentre elas:
FOAF Basics, Personal Info, Online Accounts / IM, Projects and Groups, Documents and
Images. O FOAF Basics se subdivide: Agent, Person, name, nick, title, homepage, mbox,
mbox_sha1sum, img, depiction (depicts), surname, family_name, givenname, firstName.
A classe Person representa pessoas e é uma subclasse de Agent, sendo que todas as
pessoas são consideradas agentes em FOAF.
A tabela 4.2 contém as classes que estão relacionadas a classe Person, definidas em
FOAF.
Tabela 4.2: Termos do FOAF
1. Geekcode Um geekcode textual para essa pessoa, ver http://www.geekcode.com/geek.html
2. Nome O primeiro nome de uma pessoa.
3. Sobrenome Sobrenome de uma pessoa.
4. Nome_completo Nome completo de uma pessoa.
5. Histórico Um plano de arquivo pode conter qualquer coisa. Os usos típicos dele incluíram breves comentários, pensamentos ou observações sobre o que uma pessoa tinha sido feito ultimamente
6. Imagem Uma imagem que pode ser usada para representar alguma coisa como uma foto, homepage, etc.
7. Características Abordagem à personalidade taxonômica.
8. Homepage_comercial A homepage do local de trabalho de uma pessoa (página principal)
9. Info_homepage_comercial Uma homepage contendo informações do local de trabalho de uma pessoa.
10. Homepage_escolar A página principal de uma instituição de ensino atendida por uma pessoa.
11. Conhecimento Uma pessoa conhecida desta pessoa, (indicando algum nível de reciprocidade interação entre as partes).
12. Interesses Uma página sobre tópicos de interesses de uma pessoa.
13. Tópicos de interesse Representa um interesse de uma pessoa, cujo tópico que caracteriza interesse geral.
14. Publicações O link de publicações de uma pessoa
15. Projetos_recentes O projeto atual que esta pessoa trabalha.
16. Projetos_anteriores Algum projeto que esta pessoa já trabalhou.
53
4.3 Conversão de ontologias
Para transformar uma ontologia no formato OWL em matriz de adjacência foi
utilizado o parser Thea4 (versão 0.5), que é uma biblioteca do Prolog para geração e
manipulação de conteúdo OWL, detalhado no item 4.4.1.
E para transformar uma matriz de adjacências em formato OWL, foi desenvolvido um
predicado auxiliar, onde a matriz pode ser representada por uma relação mat(C, R),
demonstrado na figura 4.9.
Figura 4.9: Matriz de adjacência de mat(C,R)
Sendo que C é a lista dos conceitos envolvidos e R é uma lista de listas, onde cada
lista interna é uma linha da matriz, sendo que as linhas em R correspondem à mesma ordem
dos conceitos em C e O zero representa um não-relacionamento, conforme quadro 4.1.
Quadro 4.1: Rotina Prolog para transformar uma matriz em lista de triplas
O quadro 4.2 mostra a rotina utilizada para transformar uma matriz de adjacências em
triplas OWL.
4 Disponível em http://www.semanticweb.gr/TheaOWLParser, último acesso em 15 de maio de 2007.
Pedra Tesoura Papel
Pedra quebra
Tesoura corta
Papel embrulha
mat([pedra,tesoura,papel], [[0,quebra,0],[0,0,corta],[embrulha,0,0]]).
54
Quadro 4.2: Rotina Prolog para transformação em triplas
4.3.1 Parser Thea
O Parser Thea usa a Semantic Web Library do SWI-Prolog analisando
gramaticalmente a serialização de documentos OWL em triplas RDF e então constrói uma
representação da ontologia em OWL.
O resultado da conversão do parser é uma representação de sintaxe abstrata de uma
ontologia OWL em termos Prolog como mostrado no quadro 4.3:
Quadro 4.3: Trecho de código OWL em termos Prolog
- ontology(OntologyID,AnnotationList).
- class(ClassID, Deprecated, Modality, AnnotationList,
DescriptionList).
- subclassOf(Description1, Description2).
- disjointSet(DescriptionList).
- equivalentSet(DescriptionList).
- property(PropertyID,Deprecated, AnnotationList,SuperPropertyList,
PropertyTypeList, DomainList, RangeList).
- annotationProperty(PropertyID).
- individual(IndividualID,AnnotationList,
TypeList,PropertyValueList).
- differentIndividuals(IndividualList).
- sameIndividuals(IndividualList).
triplas:-
mat(C,R),
trip(C,R).
trip([],_):-!.
trip([A|B],[X|Y]):-
resolve(A,X),
trip(B,Y).
resolve(_,[]):-!.
resolve(A,[0|Y]):-
resolve(A,Y).
resolve(A,[X|Y]):-
mat(C,R),
member(L,R),
enesimo(N,X,L),
enesimo(N,B,C),
assert(tripla(A,B,X)),
write(tripla(A,B,X)), nl,
resolve(A,Y).
enesimo(1,X,[X|_]).
enesimo(N,X,[_|Y]):-
enesimo(M,X,Y),
N is M + 1.
55
Onde, conforme o quadro 4.4, pode ser:
Quadro 4.4: Trecho de código OWL contendo as descrições em termos Prolog
E conforme o quadro 4.5, as restrições podem ser:
Quadro 4.5: Trecho de código OWL contendo as restrições em termos Prolog
O parser cria construções na seguinte seqüência (entre parênteses o predicado da
biblioteca Prolog), conforme quadro 4.6.
Quadro 4.6: Trecho de código OWL mostrando a seqüência criada pelo parser Thea
ClassID
Restriction
intersectionOf(DescriptionList)
unionOf(DescriptionList)
complementOf(Description)
oneOf(IndividualList)
restriction(PropertyID,allValuesFrom(Description))
restriction(PropertyID,someValuesFrom(Description))
restriction(PropertyID,cardinality(C))
restriction(PropertyID,maxcardinality(C))
restriction(PropertyID,mincardinality(C))
restriction(PropertyID,value(V))
- Classes and class descriptions (owl_parse_named_classes)
- Class axioms
Subclasses (owl_parse_subclasses)
DisjointWith (owl_parse_disjoint_classes)
EquivalentClasses (owl_parse_equivalent_classes)
- Properties (owl_parse_property)
- Annotation Properties (owl_parse_annotationProperty)
- Individual axioms (owl_parse_individual_axioms)
SameAs
DifferentFrom
- Ontology definitions (owl_parse_ontology)
- Names Individuals (owl_parse_named_individuals)
- Unamed Classes (owl_parse_unnamed_classes)
- Unamned Individuals (owl_parse_unnamed_individuals)
56
Além dos termos do Prolog que são construídos, são definidos também os seguintes
predicados dinâmicos, conforme quadro 4.7:
Quadro 4.7: Trecho de código OWL contendo predicados dinâmicos em termos Prolog
4.3.2 Ambiente SWI-Prolog
O SWI-Prolog5 é uma implementação em código aberto da linguagem de
programação Prolog. Seu autor principal é Jan Wielemaker. Em desenvolvimento contínuo
desde 1987, SWI-Prolog possui um rico conjunto de características, bibliotecas, ferramentas e
uma documentação extensiva6.
Para a conversão das ontologias, foi adicionada a biblioteca OWL_Parser e utilizado
o comando go-thea do Prolog, conforme descrito no Quadro 4.8:
Quadro 4.8: Comando do Prolog utilizando o parser Thea
Onde:
Arq_entrada: É o arquivo owl de entrada. Deve ser instanciada com um owl
existente.
Arq_saída: É o arquivo de saída. Deve ser especificado, mas pode não existir, sendo
criado neste caso.
5 Disponível em http://www.swi-prolog.org, último acesso em junho de 2007.
?-go_thea(Arq_entrada, Arq_saída, Flag).
- owl/4: For storing and tracking the use of individual
triples).
- blanknode/3: For storing and tracking the use of blank
nodes, and thus be able to detect any structure
sharing).
- owl_parser_log/2: For logging OWL parser’s activity.
57
Flag: Uma entre várias opções: "thea_as", "dlp", etc., sendo a DLP (Description
Logic Programs), utilizada neste caso, por ser no formato do Prolog.
4.3.3 Exemplo
Para o estudo de caso foram escolhidas algumas ontologias pesquisadas na Internet.
Foram visitados sites como: o site de ontologias publicadas do Google (Swoogle, 2008), o
diretório de pesquisa do SchemaWeb (SchemaWeb, 2008), entre outros.
Mesmo assim, apesar da quantidade de ontologias disponibilizadas nas localizações
visitadas, poucas ontologias puderam ser analisadas por não serem de fontes conhecidas ou
por apresentarem problemas em sua construção e, conseqüentemente, não ser possível sua
utilização no parser, não ser no formato OWL ou por outros fatores como: links quebrados,
repetições da mesma ontologia em mais de uma localização, qualidade da ontologia, entre
outros.
Para a conversão das ontologias, uma das ontologias utilizada foi a Wines.owl
presente no ambiente Protegé, conforme ilustra a figura 4.10. (PROTEGE, 2007a)
6 Extraído de http://pt.wikipedia.org/wiki/SWI-Prolog
58
Figura 4.10: Parte da Ontologia Wines criada no ambiente Protege, representando as classes e
subclasses e o código gerado no parser Thea. (PROTEGE, 2007a)
No código gerado todas as classes são subclasses, por todas serem derivadas de
owl:thing, sendo que podemos observar que há uma relação é-um entre as classes e
subclasses, onde Cotel_d_Or_region, por exemplo, é uma subclasse de Bourgogne_region,
visualizadas no quadro 4.9.
Quadro 4.9: Parte da Ontologia Wines2 gerado no Parser, representando a relação é-um entre classes e
subclasses.
'http://www.owl-ontologies.com/unnamed.owl#Bourgogne_region'(X):-
'http://www.owl-ontologies.com/unnamed.owl#Cotes_d_Or_region'(X).
% ---------------- Classes ---------
% ---------------- Subclasses ---------
'http://www.owl-ontologies.com/unnamed.owl#Wine_region'(X):-
'http://www.owl-ontologies.com/unnamed.owl#New_Zealand_region'(X).
'http://www.owl-ontologies.com/unnamed.owl#United_States_region'(X):-
'http://www.owl-ontologies.com/unnamed.owl#Edna_Valley_region'(X).
'http://www.owl-ontologies.com/unnamed.owl#French_region'(X):-
'http://www.owl-ontologies.com/unnamed.owl#Bourgogne_region'(X).
'http://www.owl-ontologies.com/unnamed.owl#Bourgogne_region'X):-
'http://www.owl-ontologies.com/unnamed.owl#Cotes_d_Or_region'X).
'http://www.owl-ontologies.com/unnamed.owl#Food'(X):-
'http://www.owl-ontologies.com/unnamed.owl#Fruit'(X).
59
As instâncias associadas às classes são geradas em uma parte em separado chamada
de individuals, conforme figura 4.11.
Figura 4.11: Parte da Ontologia Wines criada no ambiente Protegé, representando as instâncias. (PROTEGE, 2007a)
No quadro 4.10, o código OWL gerado a partir no parser Thea, visualizando as
instâncias.
Quadro 4.10: Parte da Ontologia Wines2.owl gerado no Parser, representando as instâncias.
60
4.4 Operadores Relacionais
No desenvolvimento dos algoritmos para interoperabilidade entre ontologias foram
utilizados os operadores relacionais de união, intersecção e diferença.
A figura 4.12 ilustra um exemplo de interoperabilidade dinâmica entre ontologias,
onde os mecanismos de interoperabilidade de integração e combinação, utilizando os
operadores relacionais, são aplicados de maneira automática, sem intervenção humana, pois
os mesmos ocorrem conforme a ação efetuada pelo agente.
Figura 4.12 Exemplo de interoperabilidade entre ontologias utilizando operadores relacionais
Um exemplo é no momento que um agente entra em um ambiente pervasivo, os
dados da sua ontologia são unidos com os dados da ontologia do contexto, tornando-as
disponíveis para que outro agente possa acessá-los.
A partir disso, todos os nodos que possuem informações comuns às duas ontologias,
no caso informações com dados sinônimos, serão integrados em um único nodo, no exemplo
da figura 4.11, o nodo X, gerando uma intersecção entre elas.
Serão analisadas, também, as informações que constam na ontologia do ambiente e
não estão necessariamente na ontologia do agente, gerando uma diferença entre elas.
61
Nos casos listados acima, principalmente no que diz respeito a intersecção dos dados,
a compatibilidade de termos é algo que deve ser tratado, pois é necessário listar as diferenças
entre seus termos, perceber as similaridades entre estes, detectar tanto possíveis
inconsistências quanto a falta de informação (completeza).
Preocupa-se, em particular, com a identificação de: conceitos ou propriedades com
um mesmo significado, mas rotulados com nomes diferentes; conceitos ou propriedades
rotulados com o mesmo nome, mas com significados diferentes; diferenças na escrita dos
termos das ontologias como, por exemplo: um termo no plural e outro no singular, um no
feminino e outro no masculino, e em diferentes tempos verbais; dentre outras.
Uma vez identificadas as inconsistências existentes, é preciso decidir qual ação será
tomada. Não é desejado que inconsistências sejam simplesmente ignoradas, pois é preciso
realizar a interoperabilidade entre ontologias com confiabilidade, mas, por outro lado, não é
desejado resolver todas as inconsistências existentes, pois isto aumentaria a complexidade da
solução e, conseqüentemente, seu tempo de execução.
A seguir serão detalhados os operadores de união, intersecção e diferença citados na
figura 4.12.
4.4.1 Definição
A fim de um melhor detalhamento da utilização dos operadores relacionais, foi
elaborado um exemplo com duas Ontologias O1 e O2, demonstradas a seguir.
Sendo a ontologia O1, dada por um conjunto de conceitos, conforme figura 4.13 e
definidos em C como:
C = {C1 = Pedra; C2= Tesoura; C3 = Papel}
62
Figura 4.13: Ontologia O1 modelada no Protegé, visualizando os conceitos e instâncias associadas
E um conjunto de relacionamentos, visualizados na figura 4.14 e definidos em R
como:
R = {R1= quebra; R2=corta; R3=embrulha}
Figura 4.14: Ontologia 01, modelada no Protegé, visualizando os (relacionamentos)
Deste modo, pode-se afirmar que O1 é um conjunto de pares O1 = (C, CxCxR),
visualizado na figura 4.15 e exemplificado a seguir:
63
O1=({pedra, tesoura, papel}, {(pedra, tesoura, quebra), (tesoura, papel, corta), (papel,
pedra, embrulha)})
Figura 4.15: Ontologia O1 modelada no Protegé, visualizando os conceitos e relacionamentos
O quadro 4.11 visualiza o código OWL gerado a partir da ontologia O1, onde se
verifica os conceitos Pedra e Tesoura relacionados através do atributo quebra.
Quadro 4.11: Trecho de código OWL da ontologia O1, visualizando conceitos e relacionamento
Aplicando-se o Parser Thea na ontologia O1, foi gerado um código OWL, a fim de
transformá-la em matriz de adjacências, para uma melhor representação visual, conforme o
quadro 4.12.
<owl:ObjectProperty rdf:ID="quebra">
<rdfs:domain>
<owl:Class>
<owl:unionOf rdf:parseType="Collection">
<owl:Class rdf:about="#Pedra"/>
<owl:Class rdf:about="#Tesoura"/>
</owl:unionOf>
</owl:Class>
</rdfs:domain> </owl:ObjectProperty>
64
% ---------------- Classes ---------
'__file://h:/aulas/mestrado_ucpel/downloads/thea-0.5.5/o1.owl#__Description1'(X):-
('http://www.owl-ontologies.com/Ontology1214510832.owl#Papel'(X);'http://www.owl-
ontologies.com/Ontology1214510832.owl#Pedra'(X)).
'__file://h:/aulas/mestrado_ucpel/downloads/thea-0.5.5/o1.owl#__Description3'(X):-
('http://www.owl-ontologies.com/Ontology1214510832.owl#Pedra'(X);'http://www.owl-
ontologies.com/Ontology1214510832.owl#Tesoura'(X)).
'__file://h:/aulas/mestrado_ucpel/downloads/thea-0.5.5/o1.owl#__Description4'(X):-
('http://www.owl-ontologies.com/Ontology1214510832.owl#Tesoura'(X);'http://www.owl-
ontologies.com/Ontology1214510832.owl#Papel'(X)).
Quadro 4.12: Trecho de código OWL da ontologia O1, gerado no parser Thea
Neste exemplo observa-se a formação as triplas (conceito, conceito, relacionamento),
no caso (Papel, Pedra, X), (Pedra, Tesoura, X), (Tesoura, Papel, X), onde X representa o
relacionamento formado entre os conceitos.
Além disso, a fim de testar e gerar a ontologia no Parser Thea, foi modelada a
ontologia O1, definindo-se também subclasses e instâncias associadas, demonstradas nos
quadros 4.13 e 4.14.
Quadro 4.13: Trecho de código OWL gerado no Parser Thea, representando as subclasses de O1
% ---------------- Subclasses ---------
'http://www.owl-ontologies.com/Ontology1214510832.owl#Papel'(X):-
'http://www.owl-ontologies.com/Ontology1214510832.owl#Impressão'(X).
'http://www.owl-ontologies.com/Ontology1214510832.owl#Tesoura'(X):-
'http://www.owl-ontologies.com/Ontology1214510832.owl#Profissional'(X).
'http://www.owl-ontologies.com/Ontology1214510832.owl#Pedra'(X):-
'http://www.owl-ontologies.com/Ontology1214510832.owl#Natural'(X).
65
Quadro 4.14: Trecho de código OWL gerado no Parser Thea, representando as instâncias e O1
A ontologia O2, foi modelada definindo-se um conjunto de conceitos, conforme
figura 4.16 e definidos em D como:
D = {D1 = Lápis; D2= Papel}
Figura 4.16: Ontologia O2, modelada no Protege, visualizando os conceitos
E um conjunto de relacionamentos, visualizados na figura 4.17 e definidos em S
como:
S = {S1= escreve; S2=desenha}
% ---------------- Individuals ---------
'http://www.owl-ontologies.com/Ontology1214510832.owl#Escolar'('http://www.owl-
ontologies.com/Ontology1214510832.owl#Supercort').
'http://www.owl-ontologies.com/Ontology1214510832.owl#Impressão'('http://www.owl-
ontologies.com/Ontology1214510832.owl#Ofício').
'http://www.owl-ontologies.com/Ontology1214510832.owl#Multiuso'('http://www.owl-
ontologies.com/Ontology1214510832.owl#Cabo_soft').
66
Figura 4.17: Ontologia O2, modelada no Protege, visualizando os relacionamentos
Deste modo, também podemos afirmar que O2 é um conjunto de pares O2 = (D,
DxDxS), visualizado na figura 4.18 e exemplificado a seguir:
O2=({lápis, papel}, {(lápis, papel, escreve), (lápis, papel, desenha)})
Figura 4.18: Ontologia O2, modelada no Protegé, visualizando os conceitos e relacionamentos
O quadro 4.15 visualiza o código OWL gerado a partir da ontologia O2, onde se
verifica os conceitos Papel e Lápis relacionados através do atributo escreve.
Quadro 4.15: Trecho do código OWL gerado a partir da ontologia O2
Para definição dos operadores, a seguir, C e D são conceitos, R e S são
relacionamentos e opx foi definido como o operador relacional, sendo op1 de união, op2 de
intersecção e op3 de diferença.
<owl:Ontology rdf:about=""/>
<owl:Class rdf:ID="Papel"/>
<owl:Class rdf:ID="Lápis"/>
<owl:ObjectProperty rdf:ID="escreve">
<rdfs:domain>
<owl:Class>
67
• União:
A união consiste em juntar os conjuntos de conceitos e relacionamentos das duas
ontologias O1 e 02, conforme visualizado no quadro 4.16.
Quadro 4.16: Exemplo de união
• Intersecção:
Neste caso, a ontologia resultante é concebida da união dos conjuntos de conceitos e
da intersecção dos conjuntos de relacionamentos (triplas), conforme o quadro 4.17.
Quadro 4.17: Exemplo de intersecção
• Diferença:
A diferença é o resultado da união dos conjuntos de conceitos e da diferença dos
conjuntos de relacionamentos (triplas), conforme o quadro 4.18.
Quadro 4.18: Exemplo de diferença
4.5 Algoritmos
A partir da definição dos operadores relacionais, foram desenvolvidos algoritmos que
permitem a interoperabilidade entre ontologias, onde a entrada é uma lista de ontologias em
op1 (O1, O2) = op1 ((C, R), (D, S)) = (C∪D, R∪S)
op2 (O1, O2) = op2 ((C, R), (D, S)) = (C∪D, R∩S)
op3 (O1, O2) = op3 ((C, R), (D, S)) = (C∪D, R - S)
68
OWL e a saída uma ontologia resultante, também em OWL, conforme demonstra o quadro
4.19.
Quadro 4.19: Resultado da aplicação do operador relacional
Neste caso, todos os operandos são ontologias e a ontologia resultante poderá ser a
união, intersecção ou diferença de todas as ontologias presentes na lista de ontologias de
entrada.
• União
Para o algoritmo de união foi utilizado o operador relacional op1, conforme mostra o
quadro 4.20.
Quadro 4.20: Algoritmo de união utilizando o operador op1
Sendo que, inicialmente, a entrada pode ser uma lista vazia ou uma lista de
ontologias, a seguir A,B,C representam os conceitos da primeira ontologia, representadas em
listas.
É feita, então, a união das duas ontologias, utilizando-se o predicado auxiliar do
quadro 4.21 e gerada a ontologia resultante em Ont.
Quadro 4.21: Predicado auxiliar da união
op1([ ],[ ]).
op1([Ont], [Ont]).
op1([A,B|C], Ont):-
união(A,B,X),
op1([X|C], Ont1),
união([ ], Ont1, Ont).
op(Lista_de_Ontologias, Ontologia_Resultante).
união([],C,C):-!.
união([X|C1],C2,C3):-
member(X,C2),!,união(C1,C2,C3).
união([X|C1],C2,[X|C3]):- união(C1,C2,C3).
69
O quadro 4.22, visualiza um exemplo de aplicação do algoritmo de união, no
ambiente SWI-Prolog, onde a,b,c,d,e são todos triplas (C1,C2,R).
Quadro 4.22: Exemplo1 do algoritmo de união utilizando o ambiente SWI-Prolog
No quadro 4.23, foi montado um exemplo utilizando as ontologias O1 e O2, descritas
no exemplo 5.4.1.
Quadro 4.23: Exemplo2 do algoritmo de união utilizando o ambiente SWI-Prolog
• Intersecção:
Para o algoritmo de intersecção foi utilizado o operador relacional op2, conforme
mostra o quadro 4.24.
70
Quadro 4.24: Algoritmo de intersecção utilizando o operador relacional op2
Neste algoritmo, inicialmente a entrada pode ser uma lista vazia ou uma lista de
ontologias, a seguir A,B,C representam os conceitos da primeira ontologia, representadas em
listas.
É feita, então, a intersecção das duas ontologias, utilizando-se o predicado auxiliar do
algoritmo do quadro 4.25 e gerada a ontologia resultante em Ont.
Quadro 4.25: Predicado auxiliar da intersecção
O quadro 4.26 visualiza exemplos de aplicação do algoritmo de intersecção, no
ambiente SWI-Prolog, onde a,b,c,d,e são todos triplas (C1,C2,R).
op2([ ],[ ]).
op2([Ont], [Ont]).
op2([A,B|C], Ont):-
intersec(A,B,X),
op2([X|C], Ont1),
intersec(Ont1, Ont1, Ont).
intersec([],_,[]):-!.
intersec([X|C1],C2,[X|C3]):-
member(X,C2),!,intersec(C1,C2,C3).
intersec([_|C1],C2,C3):- intersec(C1,C2,C3).
71
Quadro 4.26: Exemplo1 do algoritmo de intersecção utilizando o ambiente SWI-Prolog.
O quadro 4.27, visualiza um exemplo utilizando as ontologias O1 e O2, descritas no
exemplo 5.4.1.
Quadro 4.27: Exemplo2 do algoritmo de intersecção utilizando o ambiente SWI-Prolog.
Analisando-se o exemplo do quadro 4.27, verifica-se que é gerada uma lista vazia em
Ont, por não haverem conceitos e relacionamentos sinônimos nas duas ontologias.
• Diferença :
Para o algoritmo de diferença foi utilizado o operador relacional op3, conforme o
quadro 4.28.
Quadro 4.28: Algoritmo de diferença utilizando o operador op3
op3([C1,T1],[C2,T2],[C3,T3]):-
união(C1,C2,C3), difer(T1,T2,T3).
72
Neste algoritmo, a entrada é uma Lista de ontologias (triplas) e a saída uma Lista de
pares de conceitos. O resultado é obtido pela <<união>>, sendo feita a remoção do
componente "relacionamento" de todas as triplas das ontologias em Lista_de_Ontologias e
aplicada a diferença entre elas, descrito no quadro 4.29.
Quadro 4.29: Predicado auxiliar da diferença
O quadro 4.30, visualiza exemplos de aplicação do algoritmo de intersecção, no
ambiente SWI-Prolog, onde a,b,c,d são todos triplas (C1,C2,R).
Quadro 4.30: Exemplo1 do algoritmo de diferença utilizando o ambiente SWI-Prolog.
Como um segundo exemplo foram utilizadas as ontologias O1 e O2, descritas no
exemplo 5.4.1, demonstrado no quadro 4.31.
difer([],_,[]):-!.
difer([X|C1],C2,[X|C3]):-
not(member(X,C2)),!,difer(C1,C2,C3).
difer([_|C1],C2,C3):- difer(C1,C2,C3).
73
Quadro 4.31: Exemplo2 do algoritmo de diferença utilizando o ambiente SWI-Prolog.
No exemplo do quadro 5.25, verifica-se que o resultado contido em T3 é o conteúdo
da ontologia O1, pois foi feita a diferença entre O1 e O2, ou seja, o que pertence a O1 e não
pertence a O2.
Estes são algoritmos genéricos que podem ser aplicados em vários casos, sendo que a
entrada sempre será uma lista de ontologias (n ontologias) e que todas serão operadas com um
mesmo operador, no caso o "op".
Vale ressaltar também que estes algoritmos, apesar de não possuírem uma precisão de
100%, sua simplicidade se justifica por possuírem a finalidade de poderem ser operados em
tempo real, gerando uma economia de especificação algorítmica.
Desta forma, adéquam-se, inclusive a ontologias com estruturas grandes e que
possuem maior complexidade semântica, onde o tempo é fator determinando, pois não é
possível esperar a execução de um algoritmo enquanto os acontecimentos ocorrem.
4.6 Exemplo de interoperabilidade dinâmica entre ontologias
Para validação da proposta apresentada foi utilizado o exemplo de um congresso,
contendo em sua ontologia dados de um evento e um pesquisador que deseja apresentar um
determinado trabalho neste congresso.
No exemplo, ilustrado na figura 4.19, pode-se verificar a aplicação dos mecanismos
de interoperabilidade de integração e combinação, sendo aplicados automaticamente, sem
intervenção humana, pois os mesmos ocorrem conforme a ação efetuada pelo agente
(pesquisador).
74
Figura 4.19: Exemplo de aplicação dos mecanismos de interoperabilidade.
Enquanto o pesquisador está apresentando seu trabalho no congresso, os dados que
constam em sua ontologia são unidos com os dados da ontologia do ambiente, tornando-as
disponíveis para eventuais consultas que possam ocorrem durante a apresentação.
Quando o pesquisador termina de apresentar seu trabalho ele deixa um registro da sua
apresentação na ontologia do ambiente, sendo que este registro também será acrescentado na
sua ontologia.
Além disso, podem haver informações que constam na ontologia do congresso e que
também estejam na ontologia do pesquisador, que podem ser interessantes para ambos.
Por exemplo:
• O congresso possui em sua ontologia a classe Assunto, onde serão cadastrados
todos os assuntos abordados no evento como SMA, Ontologias, Comunidades
Virtuais, etc.
• O pesquisador possui em sua ontologia a classe Tópicos de Interesse, como
Ontologias, Banco de Dados, etc.
Unindo-se estas duas ontologias, teremos, então, uma intersecção entre esses termos,
que mesmo tendo rótulos diferentes, o conteúdo possui a mesma finalidade, mostrar as áreas
Entrada
Saída
CONGRESSO
CONGRESSO
75
de interesse de uma pessoa ou evento. Essa identificação dos termos sinônimos é possível
através da conciliação de vocabulários, demonstrados na figura 4.20.
3. Assunto Assunto deverá ser expresso por palavras chave, frases, ou códigos de classificação que descrevem o conteúdo do recurso.
13. Tópicos de interesse
Representa um interesse de uma pessoa, cujo tópico que caracteriza interesse geral.
Figura 4.20: Exemplo de conciliação de vocabulários utilizados na intersecção
Além disso, outras possibilidades poderão surgir através desta intersecção, seria o
caso da diferença, ou seja, dados que estão na ontologia do ambiente e não estão na ontologia
do agente, mas possuem uma relação entre si.
A figura 4.21 demonstra um exemplo onde os nodos A1, A2 e A3 não estão na área
de intersecção, mas estão conectados com os nodos P1, P2 e A4 das ontologias do agente e do
ambiente que possuem conexão com estes.
Desta forma observa-se a relação que existe entre os nodos das ontologias, pois nodos
que estejam ligados através de outros nodos podem contribuir para gerar novos
conhecimentos, mesmo que não sejam comuns às duas ontologias.
Figura 4.21: Exemplo de diferença com relacionamento
DC
FOAF
Área de Intersecção
Conexões entre nodos
76
No exemplo da figura 4.12, o nodo X possui relação com o nodo Y, que possui
relação com o nodo Z, desta forma podemos dizer que as informações constantes no nodo X
podem ser interessantes para o nodo Z, por possuírem uma interligação indireta.
Da mesma forma, podemos dizer que a ligação existente entre o nodo Z e W, pode ser
interessante, pois ambos pertencem a ontologias diferentes e através da sua relação podem
contribuir para gerar novas informações.
A partir desses exemplos, foi desenvolvido um algoritmo de relacionamento,
chamado de relacionado-com, utilizando um operador (op4), exemplificando no quadro 4.32.
Quadro 4.32: Algoritmo do relacionado-com utilizando o operador relacional op4
Neste algoritmo são destacados os conjuntos de relacionamentos (triplas) das
ontologias transformados em conjuntos de duplas através da remoção do 3º.componente (o
relacionamento).
O quadro 4.33, visualiza exemplos de aplicação do algoritmo relacionado-com, no
ambiente SWI-Prolog, onde a,b,c,d,e são todos triplas (C1,C2,R).
op4([ ],[ ]):-!.
.
op4([(A,B,_)|X],[(A,B)|Y]):-
not(member((A,B,_),X)),!,
op4(X,Y).
op4([_|X],Y):- op4(X,Y).
77
Quadro 4.33: Exemplo do algoritmo relacionado-com utilizando o ambiente SWI-Prolog.
4.6.1 Ontologia do Ambiente
Tomando por base essas informações foi possível identificar as correspondências
existentes entre os elementos do Dublin Core e os dados de um congresso (ambiente),
apresentados de na tabela 4.3.
Tabela 4.3: Correspondência entre os termos do Dublin Core e os dados de um evento.
Elementos Dublin Core
Dados de um congresso
1. Título II Workshop – Escola de Sistemas de agentes para ambientes colaborativos
2. Criador Universidade de Santa Cruz do Sul
3. Assunto arquitetura de sistemas de agentes para ambientes colaborativos
agentes conversacionais e de interface para ambientes colaborativos
4. Descrição O WESAAC é um evento regional, abrangendo os estados o RS, SC, PR e SP, a reunir praticamente todos os grupos de pesquisa atuantes nas áreas de Sistemas de Agentes e Ambientes Colaborativos. ...
5. Publicador Não identificada
6. Contribuidor SBC
7. Data 2008/05/28
8. Tipo Workshop
9. Formato
Os artigos devem ser submetidos em formato PDF, utilizando os estilos sugeridos pela SBC (estilo Latex ou Word, disponíveis em http://www.sbc.org.br, na seção de "Eventos"). Os artigos podem ser escritos em Português ou em Inglês, e devem ter, no máximo, 10 páginas.
10. Identificador WESAAC2008
78
11. Origem Santa Cruz do Sul, RS, Brasil
12. Linguagem Português
13. Relação http://www.unisc.br/universidade/eventos/wesaac2008
14. Abrangência Regional
15. Direitos Não identificada
Além dos termos citados na tabela 4.3, foram identificados mais sete termos que
fazem parte do domínio do congresso, que estão identificados na tabela 4.4:
Tabela 4.4: Termos complementares do Congresso
Termos Congresso Descrição
1. Público-alvo: Estudantes, professores e pesquisadores
2. Programação: Quarta-feira 28/maio –
08h00 - 09h00: Credenciamento
3. Inscrições: VALORES: Professores/Pesquisadores - R$ 30,00
4. Comissão_organizadora: Coordenação Geral do Evento
Rejane Frozza (UNISC)
Andréa Aparecida Konzen da Silva (UNISC)
5. Data_submissão: 05/04/2008
6. Data_aceitação: 05/05/2008
7. Data_versão_final: 12/05/208
A figura 4.22, mostra a modelagem da ontologia do ambiente feita no ambiente do
Protegé, utilizando os elementos do Dublin Core.
Figura 4.22: Ontologia do ambiente, utilizando termos do DC modelada no Protegé.
79
O quadro 4.34 apresenta a geração de um trecho de código OWL da ontologia do
ambiente, onde foram utilizados os 15 elementos do Dublin Core.
Quadro 4.34: Código OWL gerado da ontologia do ambiente, utilizando termos do DC.
4.6.2 Ontologia do Agente
A fim de relacionar estes dados com os dados de um pesquisador(agente) foi elaborado
um exemplo, utilizando os termos do FOAF, conforme a tabela 4.5.
Tabela 4.5: Exemplo utilizando os termos do FOAF
Geekcode Não identificado Nome Verlani
Sobrenome Hinz
Nome_completo Verlani Hinz
Histórico Mestranda em Ciência da Computação, Professora da Faculdade de Tecnologia Senac.
Imagem
Características Não identificado.
Homepage_comercial http://www.senacrs.com.br
Info_homepage_comercial http://www.senacrs.com.br/info
Homepage_escolar http://www.ucpel.tche.br
Conhecimento Luiz Antônio Moro Palazzo
Interesses http://olaria.ucpel.tche.br/ia
<Termos_Dublin_Core rdf:ID="Termos_DC"> <dc:creator rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Universidade de Santa Cruz do Sul</dc:creator> <dc:format rdf:datatype="http://www.w3.org/2001/XMLSchema#string">PDF, utilizando os estilos sugeridos pela SBC, ....</dc:format> <dc:coverage rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Regional</dc:coverage> <dc:type rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Workshop</dc:type> <dc:relation rdf:datatype="http://www.w3.org/2001/XMLSchema#string"> http://unisc.br/universidade/eventos/wesaac2008</dc:relation> <dc:subject rdf:datatype="http://www.w3.org/2001/XMLSchema#string">agentes para ambientes colaborativos</dc:subject> <dc:description rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Evento regional, abrangendo os estados RS, SC, PR, SP, ....</dc:description> <dc:source rdf:datatype="http://www.w3.org/2001/XMLSchema#string">Santa Cruz do Sul, RS, Brasil</dc:source>
80
Tópicos de interesse Ontologias, Banco de Dados, SMA
Publicações http://lattes.cnpq.br/
Projetos_recentes Estudo e Desenvolvimento de Algoritmos para Interoperabilidade entre Ontologias
Projetos_anteriores Criação de uma Ontologia de Ontologias
A figura 4.23 visualiza a modelagem da ontologia do agente (pesquisador), que
também foi feita no ambiente Protege, sendo, neste caso, utilizados os elementos do FOAF,
que estão identificados na tabela 4.5.
Figura 4.23: Ontologia do agente, utilizando termos do FOAF, modelada no Protege
O quadro 4.35 mostra um trecho do código OWL gerado na ontologia do agente
(pesquisador), onde foram utilizados os termos do FOAF.
Quadro 4.35: Trecho de código OWL da ontologia do agente, utilizando termos FOAF
<owl:Ontology rdf:about=""/> <owl:Class rdf:ID="Publicações"> <rdfs:subClassOf> <owl:Class rdf:ID="Termos_FOAF"/> </rdfs:subClassOf> </owl:Class> <owl:Class rdf:ID="Nome"> <rdfs:subClassOf> <owl:Class rdf:about="#Termos_FOAF"/> </rdfs:subClassOf> </owl:Class> <owl:Class rdf:ID="Sobrenome"> <rdfs:subClassOf> <owl:Class rdf:about="#Termos_FOAF"/> </rdfs:subClassOf> </owl:Class>
81
A partir destes dados, é possível utilizar o Parser Thea para conversão das ontologias
em triplas OWL e empregar o uso dos algoritmos desenvolvidos neste trabalho.
Cabe ressaltar que, além destes termos, tanto no ambiente como no agente, poderiam
ser explorados outros, no entanto, para que a proposta não se tornasse muito extensa e fosse
viável demonstrar neste trabalho, optou-se por um modelo abstrato de representação, servindo
este, então de modelo e podendo ser implementado em outros ambientes, como shoppings,
hospitais, museus, restaurantes, enfim ambientes pervasivos que permitam que haja interação
de agentes através de um ambiente ou até mesmo a interação agente-agente.
4.7 Considerações do capítulo
Neste capítulo foram abordados assuntos relativos à interoperabilidade entre
ontologias, sendo um dos aspectos destacados o desenvolvimento dos algoritmos,
empregando os operadores relacionais, o qual contempla o objetivo geral proposto neste
trabalho. A fim de relacionar a teoria com a prática, foram demonstrados dois exemplos com
intuito de validar a proposta.
O capítulo 5 contém as conclusões, trabalhos futuros e as publicações realizadas ao
longo deste trabalho.
82
5. Conclusões
As ontologias estão sendo amplamente utilizadas vista a necessidade de reuso e
compartilhamento de informações existente atualmente, mas para que isso seja possível é
necessário que elas consigam se comunicar de forma eficiente, utilizando mecanismos que
permitam esta interação.
Com o objetivo de entender o problema de interoperabilidade existente atualmente
foram estudados, inicialmente, assuntos referentes às ontologias, como definição, vantagens,
composição, modelagem e representação. A seguir foram abordados os mecanismos
existentes atualmente, assim como elaborados exemplos de aplicação destes.
Foram estudadas, também, as diferentes formas de representação de ontologias como
matrizes de adjacências, gramáticas de grafos, assim como a representação contextual através
das triplas OWL. Nesta etapa o parser Thea foi uma ferramenta importante, utilizada na
conversão das ontologias que estavam em OWL para o formato de triplas.
Os padrões Dublin Core e FOAF, por serem padrões definidos de fato pela W3C,
foram abordados a fim de tratarem o problema da conciliação de vocabulários.
O desenvolvimento dos algoritmos empregando os operadores relacionais se
constituiu na etapa principal deste trabalho, sendo que para testá-los foram desenvolvidos dois
exemplos práticos: um meramente ilustrativo, de dimensão menor, com o intuito de
demonstrar a viabilidade de aplicação dos algoritmos e outro, devido a sua complexidade e
dimensão elevada, apenas abstrato.
A partir dos testes realizados, foi possível concluir que a aplicação dos operadores
relacionais no desenvolvimento dos algoritmos é algo viável, atendendo as expectativas deste
trabalho, conforme demonstrados nas seções 4.5 e 4.6 desta dissertação.
Uma vez que o foco deste trabalho foi na aplicação dos mecanismos de integração e
combinação de ontologias, o processo de união de duas ou mais ontologias mostrou-se
adequado, pois possibilitou que diversas ontologias fossem unidas de uma maneira concisa. A
partir da ontologia global gerada, foi possível aplicar os operadores de intersecção e diferença,
o qual também atenderam à propósitos específicos e funcionaram com êxito.
Além disso, visto a vasta gama de possibilidades que podem surgir com o
desenvolvimento deste trabalho, no decorrer deste, verificou-se, a possibilidade de exploração
83
de termos que possuem interligação com termos de outras ontologias, contribuindo para a
geração de novos conhecimentos, o qual também foi explorado e testado com êxito na seção
4.6.
5.1 Trabalhos futuros
Na perspectiva de dar continuidade à este trabalho, surgem inúmeras possibilidades,
sendo algumas delas listadas abaixo:
• A aplicação destes operadores relacionais à outros mecanismos de
interoperabilidade estudados, assim como estudar a possibilidade de criar
novos que atendam à outras necessidades.
• Estudar a relevância dos relacionamentos, pois neste trabalho não foi
explorado o tipo de relacionamento, mas somente se existia uma relação entre
dois ou mais conceitos.
• A questão da conciliação de vocabulários também é algo que pode ser
explorado a partir deste trabalho, pois a compatibilidade de termos é uma
questão muito questionada atualmente.
• A aplicação dos algoritmos desenvolvidos a serem implementados em uma
ferramenta de desenvolvimento, que opere em tempo real e em um ambiente
pervasivo, tornando-se, assim, uma possível referência para os que pretendem
utilizá-la em um caso prático.
5.2 Publicações realizadas
Ao longo de seu desenvolvimento, este trabalho teve seus resultados divulgados
através de publicações. As principais estão relacionadas a seguir:
• WESAAC 2008. HINZ, T. V. ; PALAZZO, L. A. M. ; SILVA, R. E. S. . Suporte
Ambiental à Colaboração em Sistemas Multiagentes. In: II Workshop - Escola de
Sistemas de Agentes para Ambientes Colaborativos, 2008, Santa Cruz do Sul. II
Workshop - Escola de Sistemas de Agentes para Ambientes Colaborativos, 2008.
84
• WESAAC 2007. HINZ, T. V. ; PALAZZO, L. A. M. . Colaboração em Sistemas
Multiagentes Modelados por Ontologias. In: WESAAC 2007: Workshop-Escola de
Sistemas de Agentes para Ambientes Colaborativos, 2007, Pelotas. Workshop-
Escola de Sistemas de Agentes para Ambientes Colaborativos, 2007.
• II Oficina de Iniciação Científica. HINZ, T. V. ; LADISLAU, J. ; YAMIN, A.
C.; PALAZZO, L. A. M. . O Emprego de Ontologias Dinâmicas para Modelar a
Mobilidade de Agentes em um Ambiente Pervasivo. In: II Oficina de Iniciação
Científica - Fatec Senac, 2006, Pelotas. Anais da II Oficina de Iniciação Científica -
Fatec Senac. Porto Alegre : Senac, 2006.
• II Oficina de Iniciação Científica. HINZ, T. V. ; PEREIRA, D. R. ; PALAZZO,
L. A. M. ; SILVA, R. E. S. . Utilização do Protegé 3.1.1 na Modelagem de uma
Ontologia Acadêmica. In: II Oficina de Iniciação Científica - Fatec Senac, 2006,
Pelotas. Anais da II Oficina de Iniciação Científica - Fatec Senac. Porto Alegre :
Senac, 2006.
85
6. Bibliografia
ALMEIDA, M.B.; BAX. M.P. Uma visão geral sobre ontologias: pesquisa sobre definições,
tipos, aplicações, métodos de avaliação e de construção. Ci. Inf., Brasília, v. 32, n. 3, p. 7-
20, set./dez. 2003. Disponível em < http://www.ibict.br/cienciadainformacao>. Acesso em
abril de 2006.
ANTONIOU, G.; VAN HARMELEN, F.. A Semantic Web Prime Massachusetts Institute of
Technology, 2004.
ARPÍREZ, J. C. et al. Web ODE: a scalable workbench for ontological engineering. In:
INTERNATIONAL CONFERENCE ON KNOWLEDGE CAPTURE. PROCEEDINGS.
Victoria, British Columbia, Canada, 2001.
BAADER, F. , CALVANESE, D., D. L. MCGUINNESS, D.L., NARDI, D., PATEL-
SCHNEIDER, P.F apud : The Description Logic Handbook: Theory, Implementation,
Applications. Cambridge University Press, Cambridge, UK, 2003.
BENJAMINS, R. Knowledge Engineering and Ontologies. Disponível em
<http://www.swi.psy.uva.nl/usr/ richard/home.html>. Acesso em maio de 2006.
BERNERS-LEE, T.; HENDLER, J.; LASSILA, O. The Semantic Web., Scientific
American. May, 2001.
BORST, W. N. Construction of engineering ontologies. 1997. Tese (Doutorado). Disponível
em: <http://www.ub.utwente.nl/webdocs/inf/1/t0000004.pdf>. Acesso em maio de 2006.
BRACHMAN, R.J., FIKES, R.E. and LEVESQUE, H.J.. Krypton: A functional approach
to knowledge representation. IEEE Computer (Special Issue on Knowledge
Representation), 16(10):67-73, October 1983.
CORAZZON, R. What is ontology? [S. l. : s. n.], 2002. Disponível em
<http://www.formalontology.it/ section_4.htm>. Acesso em julho de 2006.
DAVIES, J; FENSEL, D; VAN HARMELEN, F. . Towards the Semantic Web: Ontology
driven knowledge management. John Wiley, West Sussex, 2003.
86
DOMINGUE, J.; MOTTA, E. A; CORCHO, O. Knowledge modeling in web onto and
OCML: a user guide. [ S. l. : s. n.], 1999. Disponível em: <http://kmi.open.ac.uk/projects/
webonto/user _guide. 2.4.pdf>. Acesso em junho de 2006.
DC. Dublin Core Metadada Initiative. “Dublin Core metadada element set, version 1.1:
reference description”. Disponível em <http://dublincore.org/documents/dces/> Acesso
em abril de 2008.
FARQUHAR, A.; FIKES, R.; RICE, J. The ontolingua server: USA: a tool for collaborative
ontology construction. Duluth : Academic Press, 1997. p. 707-727.
FELICÍSSIMO, C. H. Interoperabilidade Semântica na Web: Uma Estratégia para o
Alinhamento Taxonômico de Ontologias. Dissertação de Mestrado. Rio de Janeiro: PUC,
Departamento de Informática, 2004.
FOAF. Friend Of A Fried – Vocabulary Specification. Disponível em
<http://xmlns.com/foaf/0.1/#term_interest>. Acesso em abril de 2008.
GÓMEZ-PÉREZ, A.; FERNANDEZ-LÓPEZ, M.; CORCHO, O. Ontological
engineering. London, Springer, 2004.
GRUBER, T. What is an ontology? [S. l. : s. n.], 1996. Disponível em <http://www-
ksl.stanford.edu/ kst/ what-is-an-ontology.html>. Acesso em setembro de. 2006.
GRUBER, T. Ontolíngua: a mechanism to suport portable ontologies. Stanford: Knowledge
System Laboratory, Stanford University, 2003. Techincal Report.
GUARINO, N. (1998). Formal Ontology and Information Systems. Disponível em
<http://www.loa-cnr.it/Papers/FOIS98.pdf>. Acesso em setembro de 2006.
HARTMANN, J.; PALMA, R.; SURE, Y. OMV – Ontology Metadata Vocabulary.
Disponível em <http://omv.ontoware.org>. Acesso em novembro de 2006.
HORROCKS, I.; SATTLER, U.; TOBIES, S. Practical reasoning for expressive
description logics. Logic Journal of the IGPL, v. 8, n. 3, p. 239-264, may 2000.
87
LIBRELOTTO, G.R., RAMALHO, J.C., HENRIQUES, P.R. TM-Builder: Um Construtor
de Ontologias Baseado em Topic Maps, XXIX Conferencia Latinoamericana de
Informática, 2003.
MAEDCHE, A. S. Discovering Conceptual Relations from Text. Techical Report 400,
University of Karlsruhe, Institute AIFB, 76128 Karlsruhe, Germany. Fevereiro de 2000.
Disponível em <http://www.aifb.unikarlsruhe.de/Publikationen/showPublikationen?
id_db=50> Acesso em Maio de 2008.
MAEDCHE, A.; VOLZ, R. The text-to-onto ontology extraction and maintenance
environment to appear. In: PROCEEDINGS OF THE ICDM WORKSHOP ON
INTEGRATIN DATA MINING AND KNOWLEDGE MANAGEMENT, 2001, San Jose,
California. [S. l. : .n.], 2001.
MAHALINGAM, K.; HUHNS, M. N. An ontology tool for query formulation in an agent-
based context. In: IFCIS INTERNATIONAL CONFERENCE ON COOPERATIVE
INFORMATION SYSTEMS, 2., 1997, Kiawah Island, SC. [S. l. : s. n.], 1997. p. 170.
MATTHEW, H.; KNUBLAUCH, H.; ALAN, R.;STEVENS, R.; WROE, C.. A Practical
Guide To Building OWL Ontologies Using The Protégé-OWL Plugin and CO-ODE Tools.
Manchester University, England, 2004.
MCGUINNESS, D. L.; FIKES, R.; RICE, J., and WILDER, S.. The Chimaera Ontology
Environment." Proceedings of the Seventeenth National Conference on Artificial
Intelligence (AAAI 2000). Austin, Texas. July 30 - August 3, 2000.
MILLER, G. A. WordNet: a lexical database for English. Communications of the ACM, v.
38, n. 11, p. 39-41, nov. 1995.
MINSKY, M.A. A Framework for Representing Knowledge. McGraw-Hill, NewYork, 1975
MIZOGUCHI, R. Tutorial on ontological engineering. The Institute of Scientific and
Industrial Research, Osaka University.
NOY, N. F. Presentation: Ontologies and tools. 1999. Disponível em:
<http://protege.stanford.edu/publications/ OntologiesAndTools/OntologiesAndTools.
ppt>. Acesso em junho de 2006.
88
NOY, F. N.; GUINNESS, D. L. Ontology development 101: a guide to create your first
ontology. Stanford University, USA, 2002. Disponível em
<http://ksl.stanford.edu/people/dlm/papers/ontology-tutorial-noy-mcguinness.doc>.
Acesso em setembro de 2006.
NOY, N.; MUSEN, M. SMART. Automated Support for Ontology Merging and Alignment.
Banff Workshop on Knowledge Acquisition, Modeling, and Management, Banff, Alberta,
Canada, 1999.
NOY, N.; MUSEN, M. The PROMPT Suite: Interactive Tools For Ontology Merging And
Mapping. International Journal of Human-Computer Studies, 2003.
PALAZZO, L.A. M. Introdução à Programação Prolog. EDUCAT, Pelotas, 1997.
PALAZZO, L.A. M. Projeto e Construção de Ontologias. Disponível em
<http://ia.ucpel.tche.br/~lpalazzo/Aulas/Ontolog/PCO3.ppt>. Acesso em abril de 2007.
PALAZZO, L.; PONTES, A.; ULYSSEA, M.; PORTO, P. Comunidades Virtuais de
Aprendizado Adaptativo. In: Conferência Nacional em Ciência, Tecnologia e Inovação.
Ministério da Ciência e Tecnologia, Florianópolis, 2001.
PINTO, S.; GOMEZ-PEREZ, A.; MARTINS, J. Some Issues on Ontology Integration.
Workshop on Ontologies and Problem Solving Methods: Lessons Learned and Future
Trends, 1999.
RICH, E. Artificial Intelligence. McGraw-Hill Book Company, 1983.
RICHARDSON, R.; SMEATON, A. F.; MURPHY, J. Using WordNet as Knowledge Base
for Measuring Semantic Similarity between Words. Technical Report CA-1294, Dublin
City University, School of Computer Applications, 1994. Disponível em:
[http://www.computing.dcu.ie/research/papers/1994/1294.ps], acesso em maio de 2008.
SCHEMAWEB. SchemaWeb directory. Disponível em http://www.schemaweb.info/. Acesso
em junho 2007.
SCIME, A. Web Mining: Aplications and Techniques. State University of New York College
at Brockport, USA, 2004.
89
SOUZA, M. I. F., VENDRUSCULO, L. G., MELO, G. C. Metadados para a descrição de
recursos de informação eletrônica: utilização do padrão Dublin Core. Ciência da
Informação, v. 29, n. 1, p. 93-102, abr. 2000.
SOWA, J. F. Knowledge Representation: Logical, Philosophical, and Computational
Foundation. Brooks Cole Publishing Co., Pacific Grove, CA, 2000. Actual publication
date, 16 August 1999.
SOWA, J. F. Building, sharing and merging ontologies. Tutorial. [S. 1. : s. n.], 1999.
Disponível em <http://users.bestweb.net/~sowa/ontology/ontoshar.htm>. Acesso em
setembro de 2006.
SKUCE, D. IKARUS. CODE4: a unified system for managing conceptual knowledge.
International Journal of Human-Computer Studies, n. 42, p. 413-451, 1995.
SWARTOUT, B. et al. Toward distributed use of large-scale ontologies. In:
PROCEEDINGS OF AAAI97 SPRING SYMPOSIUM SERIES WORKSHOP ON
ONTOLOGICAL ENGINEERING, 1997. [S. l.] : AAAI Press, 1997. p. 138-148.
SWOOGLE. Swoogle: A Semantic Web Search. Disponível em < http://swoogle.umbc.edu/>.
Acesso em junho de 2007.
WOODS, W.A. What's in a link : Foundations for semantic networks. In D.G. Bobrow and
A. Collins, editors, Representation and Understanding: Studies in Cognitive Science.
Academic Press, New York, 1975.
OWL. Web Ontology Language Overview. Disponível em <http://www.w3.org/TR/owl-
features>. Acesso em novembro de 2006.
PROTEGE. Protégé Project. Disponível em: <http://protege.stanford.edu/>. Acesso em
junho de 2007a.
PROTEGE. Protégé Contributions Library. Disponível em <http://protege.stanford.edu/
plugins.html/>. Acesso em junho de 2007b.
PROTEGE. Protégé PROMPT Plug-In. Disponível em <http://protege.stanford.edu/plugins/
prompt/prompt.html/>. Acesso em junho de 2007c.
90
RUSSI, D. T. A.; SILVA, F. A. O Uso da Gramática de Grafos em Especificações Formais.
Disponível em < http://fipp.unoeste.br/~chico/artigo_gramatica_de_grafos.pdf>. Acesso
em junho de 2008.
W3C. W3C Semantic Web Activity. Disponível em: <http://www.w3.org/2001/sw/>. Acesso
em junho de 2008.