Ontologia para Desenvolvedores

Este texto não tem objetivo de ensinar completamente a desenvolver ontologias, mas repassar conceitos rápidos sobre o assunto (a não ser que exista demanda para tal aqui no blog).

Há algum tempo existe uma demanda no desenvolvimento de sistemas que tem por objetivo a busca semântica de informações. Seja no espaço acadêmico ou profissional. O problema que tem recebido bastante atenção, que eu vejo, é na forma como estruturamos as informações. Nos bancos de dados relacionais a estrutura é rígida no sentido das tabelas estarem relacionadas entre si e as consultas precisam seguir pelas chaves (PK e FK) ou por funções/procedimentos, minerando informações na base. Isso não é um problema, é o formato mais largamente usado de persistência de dados. O problema que vejo está na racionalização ou inferência das informações que estão contidas nessas bases.

É claro que também é possível realizar deduções em bancos de dados relacionais ou em qualquer arquitetura que os utilize. Talvez pela construção de algoritmos de busca e tratamento de informações, utilizando text mining, lógica fuzzy, ou alguma outra técnica. Mas a ideia aqui é mostrar uma alternativa poderosa para quem precisa de uma estrutura focada na racionalização, ou seja, busca de informações que estão lá nos dados e o significado daqueles valores. Inclusive, dependendo do nível desta alternativa, é possível deixar que a própria estrutura pense sobre seus próprios dados, deixando como única preocupação ao desenvolvedor a “pergunta” que se deseja fornecer ao banco de dados semântico.

Ontologia! Como todo bom ontologista eu preciso achar que esta é uma solução elegante para a semântica, é bonito de ler o grafo, sério mesmo, dá pra mandar fazer um pôster e colar na parede como um “mural do conhecimento”, heheh. Porque devo usar ontologia? Um dos primeiros artigos que li a respeito, na época da graduação, foi este aqui de Stanford. Muitas instituições, como centros militares, biologia, medicina, KMS (sistemas de gerenciamento de conhecimento em geral) usam esta estrutura porque é útil para quem quer conhecer sobre uma determinada área e ao mesmo tempo redistribuir informações sobre ela, incluindo análise do conhecimento.

onto-anime-class

Hierarquia de classes (conceitos).

Onto_Anime

Ontologia com os arcos de relacionamentos (predicados).

Ontologia é um estudo sobre o significado das coisas que se iniciou pelas viagens dos filosóficos antigos e que depois (bem depois) entrou na voadora no ramo da Inteligência Artificial (na parte Distribuída, ontologia é uma rede semântica). Curto e grosso: desta forma temos os nodos, que são os conceitos sobre alguma coisa. Os arcos de um nodo ao outro são os relacionamentos entre esses conceitos, predicados que dão o valor semântico (existem alguns tipos de arcos, são as propriedades de objeto). Considere que cada conceito na sua árvore do conhecimento é uma classe, que contém atributos que caracterizam aquele conceito. Nas imagens, peguei um exemplo de uma ontologia representando o conhecimento sobre a equipe na produção de séries de TV que encontrei do Haroldo Rojas da Universidade de San Carlos da Guatemala. Um estúdio pode ter departamentos de animação, música, etc. A classe “Estudio” pode ter um atributo chamado Nome, as classes do departamento “Pessoal” descrevem funções onde cada funcionário também tem um nome. Assim, constituímos uma propriedade de dados chamado Nome que será uma string e que por sua vez será usado como atributo destas classes. Isso lembra um pouco orientação a objeto, legal né? Lembrando que as instâncias destas classes são chamadas de indivíduos, estes “objetos” são os valores das informações na sua ontologia. Todo o conhecimento sobre uma determinada área fica centralizado nesta rede, que é bem legal para ser lido por humanos e as máquinas também entendem. Bem, este texto serve apenas como uma desmistificação sobre os conceitos iniciais da ontologia. Existem mais coisas a serem estudadas só na parte de estrutura da ontologia. Como toda a engenharia de desenvolvimento, linguagens específicas tanto para modelar uma ontologia, e sua representação. Estudaríamos desde Prolog, Ontolingua, até as recomendações para a web baseados em XML como RDF e OWL. Entretanto este texto é para ser uma prévia básica a desenvolvedores.

Existe uma gama de bibliotecas que trabalham na manipulação de ontologias, recomendo acessar o site da W3C sobre a web semântica que contém um glossário de libs (http://www.w3.org/2001/sw/wiki/Tools) existentes para cada linguagem de programação. Ainda quero muito testar algumas em PHP, mas por necessidade precisei testar uma famosa biblioteca em Java, que é o Jena.

Jena é mantida pelos laboratórios da HP e tem uma boa documentação. Caso precisar de auxílio para configurar a referência da biblioteca no Eclipse ou Netbenas é só deixar um comentário (tutoriais estão prontos). Algumas outras bibliotecas, como a Corese, utilizam os componentes do Jena incluindo algumas funcionalidades adicionais.

Código exemplo:

//supondo que tenha uma ontologia salva para manipular
String arquivo = "file:X:/repositorio_ontologias/..../sanduiche.owl"

//criar um espaco na memoria para uma ontologia, baseada em OWL
OntModel modelo = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);

//usar FileManager para abrir o arquivo
InputStream in = FileManager.get().open(arquivo);

//ler o documento, propriamente dito
modelo.read(new InputStreamReader(in), "");

// retorna qual linguagem a ontologia usa
System.out.println(modelo.getProfile());

//lista as subclasses
OntClass pessoal = modelo.getOntClass(ontologia + "Pessoal");
for (Iterator i = pessoal.listSubClasses(); i.hasNext(); ) {
OntClass c = (OntClass) i.next();
System.out.println( c.getLocalName());

}

// lista todas as classes da ontologia
for (Iterator i = modelo.listClasses(); i.hasNext();){
System.out.println(i.next());
}

A partir da linha 11 é possível manipular a ontologia (alguns exemplos são vistos nas linhas posteriores), é claro que existem diversos métodos e arquiteturas que não coube explicação aqui. Para mais informações recomendo ler alguma documentação do Jena, seu Javadoc e vários exemplos que podem ser encontrados em sites como da IBM – developerWorks. Outra tecnologia necessária a utilizar é a SPARQL, que é um “SQL para documentos semânticos”. SPARQL é usado para realizar consultas na ontologia. No exemplo SP1, gostaríamos de saber qual o indivíduo que tenham em seu nome a sentença “Bea”, neste caso um possível resultado seria a indivídua Beatriz que é uma atriz (ID do indivíduo será retornado junto). Prefixo determina a URI, que é o endereço da ontologia (pode incluir dentro do próprio SPARQL, mas assim fica mais fácil de ler).

SP1:

PREFIX uriontologia: <http://www.owl-ontologies.com/Onto_Anime.owl#&gt;

SELECT ?Individuo ?Nome

WHERE {

?Individuo uriontologia:Nome

?Nome.FILTER regex(?Nome,’Bea’) .

}

Outro exemplo, em SP2, é possível consultar na ontologia onde que Matsumoto trabalha e o que ele faz. Neste caso pode retornar algo como Fotógrafo na coluna ?N e Série X na coluna ?S.

SP2:

PREFIX uriontologia: <http://www.owl-ontologies.com/Onto_Anime.owl#&gt;

SELECT ?N ?S

WHERE{

?N uriontologia:Nome “Matsumoto”;

uriontologia:Trabalha_Em ?S.

}

A partir disso muitas outras relações podem ser feitas, eu estou gostando de trabalhar com isso. Até porqueo mais legal é poder trabalhar interdisciplinar como ontologista, de uma forma ou outra na modelagem já se adquire conhecimento de especialistas sobre a área fim da ontologia. Dependendo no quer for aplicar é necessário trabalhar com médicos, biólogos, gestores, etc. Nos EUA já existe a profissão de Analista em Ontologia ou Ontologista. Por enquanto fica esta prévia, tem milhares de tópicos dentro de ontologia que poderiam ser escritos.

Anúncios
  • Trackback are closed
  • Comentários (10)
    • Ernando Gomes
    • 12 de junho de 2012

    Parabéns pelo texto!

    Você teria algum exemplo de código explicando o processe de inferência na ontologia?

    • Patricia
    • 26 de setembro de 2012

    Olá… Estou fazendo meu tcc e vou utilizar ontologias, só que não tenho a minima ideia de como criar uma ontologia utilizando o Jena e a linguagem OWL (tipo, não sei se o Jena gera o código OWL, se tenho que utilizar um editor de ontologias.. to perdidinha!)

    • Olá Patricia,

      É necessário inicialmente compreender toda a teoria da Ontologia (não necessariamente desde o campo da filosofia, pode iniciar os estudos computacionais diretamente). Então aconselho a repassar por todos os conceitos do o que é uma ontologia, metodologias de ontologias e só depois partir para estudar as ferramentas. Como exemplo de referências e estudos você pode dar uma olhada na seção 2.1 na minha qualificação de mestrado, onde realizei uma profunda (não completa) revisão bibliográfica sobre ontologias (se faltar uma referência me avise), nesse link: https://www.dropbox.com/s/y25of7sbx1gmy28/capitulo-ontologia.pdf

      Não sei qual a sua intenção de trabalho no TCC, o que eu utilizo como ambiente de desenvolvimento é um editor de ontologias (Protégé é o meu favorito por enquanto) para construir a ontologia, sendo que este editor pode gerar o arquivo codificado em OWL. Depois utilizo alguma biblioteca de programação, como o Jena, para utilizar/manipular, que neste caso, seria em Java.

      Tenho anotado como pauta, pesquisar um compilador de linguagem de ontologias, mas até então só encontrei editores que programo “visualmente” a rede semântica e o código em OWL sai pronto. A única coisa boa disso é que não precisa conhecer a linguagem de ontologia a fundo 😉

      Se precisar, em Jena, você tem como criar conceitos e adicionar a ontologia, ou seja, sem a utilização do editor e sim via programação. Na documentação do Jena tem mais detalhes, neste link (recomendo ler todo o conteúdo) ou diretamente na seção sobre Ontology classes and basic class expressions

      Resumindo: construo ontologias em um editor, no editor também posso testar minhas consultas SPARQL, depois via programação com Jena (em Java), desenvolvo sistemas que utilizem a ontologia, lembrando que Jena possibilita criar e adicionar mais conceitos a ontologia, porque Jena instancia seu arquivo OWL em memória para manipular toda a rede semântica. Creio que em PHP também tenha alguma bilioteca para utilizar com ontologias, só testar as que existirem naquele link do post onde diz glossário de libs, mas por enquanto só utilizei Jena.

      Qualquer coisa fico a disposição via e-mail: fabio.aiub at gmail.com

  1. Pessoal,

    Eu sou dummy em Jena e lendo esta página: http://jena.apache.org/documentation/ontology/index.html#experimental-ontology-tools, mais especificamente in Figure 5(iii) -“direct inferred relationship” Eu encontrei exatamente o que eu precisava. Basicamente, minha OntModel necessita respeitar a seguinte regra: “Não posso manter afirmações que podem ser inferidas”. Infelizmente eu não sei como materializar esta ideia em Jena.

    Meu código exemplo:

    String baseUri=”http://entidades.owl”;
    OntModel base = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);

    OntClass studant = base.createClass(baseUri +”#Student”);

    OntClass person = base.createClass(baseUri +”#Person”);
    OntClass ser = base.createClass(baseUri +”#ThingLive”);

    Property isA = base.createTransitiveProperty(baseUri+”#IsA”, true);
    nome.addDomain(person);
    base.add(new StatementImpl(studant, isA, person));
    base.add(new StatementImpl(person, isA, ser));

    base.createIndividual(baseUri+”#JonhDoe”,studant);
    base.createIndividual(baseUri+”#JonhDoe”,person);
    base.createIndividual(baseUri+”#JonhDoe”,ser);
    base.write(System.out);

    OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_TRANS_INF,base);
    model.write(System.out);

    Bem,

    1. Eu tento construir uma propriedade “isA” como sendo “transitiveProperty” mas o reasoner não reconhece isso. Como eu posso concertar isso ?

    2. Se eu mudo as seguintes linhas:
    base.add(new StatementImpl(studant, isA, person));
    base.add(new StatementImpl(person, isA, ser));

    to:

    person.addSubClass(student);
    ser.addSubClass(person);

    O reasoner consegue inferir perfeitamente o que eu preciso, entretanto, OntModel “base” e OntModel “model” mostram o mesmo RDF.

    O que eu posso fazer para ver essa mudança refletida no arquivo RDF gerado ?

    Muito obrigado senhores.

    • Olá zegildo,

      Obrigado por dividir sua dúvida. Também não sou lá expert, tenho trabalho pouco com a geração de ontologias direto do Jena, mas vamos lá:

      (1) Sobre gravação em arquivo
      Utilizei para análise pelo menos uma saída em arquivo (model.write()). Adicione no final do seu exemplo o seguinte código:

      //utilizando lib FileWriter vou preparar "arquivo" para ser um descritor de um arquivo.owl
      FileWriter arquivo = null;
      try {
          //caminho para o arquivo, deixei junto do projeto mesmo
          arquivo = new FileWriter("teste.owl");
          //se não existir arquivo, o mesmo será criado, se não, será reescrito
          } catch (IOException e) {
          	e.printStackTrace(); //verificando problemas
          	}
      //determinando que o fluxo de saida vai para o arquivo e não para a tela            
      BufferedWriter out = new BufferedWriter(arquivo);
      //"RDF/XML para saída eficiente e menos legível, pode utilizar RDF/XML-ABBREV"        
      model.write(out, "RDF/XML");
      

      Mais detalhes em Jena I/O

      (2) Sobre Propriedade Transitiva
      Fiz algumas codificações e testes sobre a sua dúvida, também verifiquei a página do Jena em questão, pela figura, você deseja realizar uma estrutura com relações diretas? Algo como Student -> Person -> ThingLive ? Então pode-se inferir que Student é Pessoa e Student também é ThingLive, é isso?

      Se sim, utilize os procedimentos addSubClass(), se não, no caso da sua codificação de Property isA vou acabar tendo no final uma ontologia com a mesma propriedade de objeto sendo transitiva-funcional sem as relações entre os conceitos que descrevi acima. Se for este caso de ter uma hierarquia de Student até Thinglive a função addSubClass() já irá construir essa relação. Pelo menos utilizei um editor de ontologias para analisar cada geração de arquivo.owl e o seu código abaixo com as seguintes alterações resultou na hierarquia que mencionei:

      String baseUri="http://entidades.owl";
      OntModel base = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM);
      
      OntClass studant = base.createClass(baseUri +"#Student");
      OntClass person = base.createClass(baseUri +"#Person");
      OntClass ser = base.createClass(baseUri +"#ThingLive");
      
      person.addSubClass(studant);
      ser.addSubClass(person);
      
      base.createIndividual(baseUri+"#JonhDoe",studant);
      base.createIndividual(baseUri+"#JonhDoe",person);
      base.createIndividual(baseUri+"#JonhDoe",ser);
      base.write(System.out);
      
      OntModel model = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM_TRANS_INF,base);
      model.write(System.out);
      

      Comparei as saídas no terminal e no arquivo e visualizei as alterações normais, seja em OntModel “base” e OntModel “model”.

      Agora a questão de criar explicitamente a propriedade transitiva, realmente tenho pouca experiência, não sei se estes links abaixo podem ajudar:
      http://answers.semanticweb.com/questions/3555/jena-reasoning-failing-on-transitive-property
      e
      http://stackoverflow.com/questions/9852611/need-to-make-a-property-transitive

      Não sei se entendi bem o que repassou José. Vi também que postou a dúvida no Stackoverflow e lá está cheio de especialistas no assunto. Desta forma gostaria muito que retornasse aqui com uma solução que tenha encontrado.

      Obrigado e abraço.

    • Patricia
    • 3 de outubro de 2012

    Então.. eu vou usar o Jena para a criação da ontologia… Preciso criar uma ontologia para um veículo autonomo! Estou estudando o Jena e ontologias a um tempinho já, mas achei um tema bastante complexo. =) Aos poucos estou entendendo… Obrigada pela ajuda!!!

    • É Patricia, quanto mais se estuda Ontologia, mas há o que estudar, hehehe. Ontologia para um robô conhecer mais sobre o seu ambiente de operação e criar novos conhecimentos aumentando/criando conceitos na ontologia? Interessante isso.

    • Rodrigo
    • 16 de outubro de 2012

    Olá, Fábio,

    Achei muito interessante seu blog.

    Queria ver se vc ou alguém que leia pode me ajudar com uma dúvida em SPARQL.
    Estou tentando achar uma forma de realizar uma consulta para uma ontologia que criei.

    Preciso encontrar a diferença entre 2 conjuntos.
    Imagine um conjunto A que contanha, por exemplo, todos os filmes de uma coleção. E um conjunto B todos os filmes que o dono tenha visto dessa coleção.
    Quais os filmes que o dono não viu?
    Ou seja tudo q está em A que não está em B.

    abraços

    • Rodrigo,

      Vou tentar orientar. Talvez a palavra-chave MINUS possa ser útil para você (ou não, hehe). Precisávamos saber como está organizada a sua ontologia. No seu caso, vamos supor que tenhamos uma ontologia com as classes Filme e Proprietario. Além disso, também exista uma propriedade de objeto chamada Assistido, essa propriedade faz o relacionamento tendo como domínio Filme e alvo Proprietario, logo: Filme -> [Assistido] – > Proprietario.

      Caso se deseja consultar quais filmes não foram assistidos pelo proprietario, podemos ter o seguinte:

      PREFIX ontologia: <http://www.local_ontologia.com/nome_ontologia.owl#>
      
      SELECT ?filme
      WHERE{
         ?filme a ontologia:filme.
         ?filme ontologia:Nome ?Nome.
      
         MINUS{ ?filme ontologia:Assistido ?Assistido }	
      }
      

      Onde selecione cada filme, com seu nome, MENOS aqueles que possuem a propriedade Assistido vazia, ou seja, se tenho algum indivíduo Filme que não tem relação Assistido com nenhum proprietário, não vai aparecer porque MINUS subtrai isso da consulta. MINUS só funciona em SPARQL 1.1, existe outros esquemas que podem ser feitos com OPTIONAL (parecido com o OUTER JOIN do SQL) e NOT EXISTS. Em SPARQL 1.0 é necessário usar a função de FILTER() com a função de bound() para filtrar o que não se deseja.

      É claro que agora temos outro problema que é filtrar por proprietário, para que mostre filmes não assistidos por um determinado dono. É só utilizar a função FILTER, mas aí é outra história 😉

      Não sei se era isso, abraços…

Comentários encerrados.
%d blogueiros gostam disto: