 |
Tutorial: Noções básicas para uso do Protege |
| O Protege é um editor de ontologias desenvolvido pela
University of Stanford. Para maiores informaçoes, acesse o site do Protege em Stanford: Site do Protege  |
Protege Wiki |
Equipe Protege |
Esse tutorial apresenta uma introdução ao Protege, um ambiente para criação e edição de ontologias e bases de conhecimento, que permite ao usuário iniciar o projeto de uma ontologia rápida e intuitivamente. O usuário aprende a criar, modificar e salvar um projeto no Protege. Será criado um projeto chamado "tutorial", o qual contém umas poucas classes e exemplos de um exemplo, denominado newspaper, que acompanha a instalação do Protege. Uma vez lido o tutorial, se está pronto para explorar o Protege por conta própria.
Nem todos os usuários do Protege estão familiarizados com
o projeto e o desenvolvimento de ontologias. Dessa forma, além de introduzir
a interface do Protege, esse tutorial apresenta uma breve visão geral de
alguns conceitos básicos do projeto de ontologias e se baseia nos conceitos
descritos no artigo Ontology Development 101
. Caso se esteja familiarizado com o
projeto de ontologias, pode-se pular diretamente para o item "Criar e
salvar um projeto". Para documentação mais completa, tutoriais, artigos
e apresentações, veja a página de documentação (documentation
page) no site do Protege.
Uma ontologia descreve os conceitos básicos em um domínio de conhecimento e define relações entre eles. Os fundamentos básicos do projeto de ontologias incluem:
Classes ou conceitos;
Propriedades de cada conceito, que descrevem características e atributos de um conceitos (slots, algumas vezes denominados "papéis" ou "propriedades");
Facetas (facets), algumas vezes denominadas "restrições sobre slots".
Uma ontologia mais um conjunto de instâncias individuais de classes constitui uma base de conhecimento.
Uma ontologia fornece um vocabulário comum para pesquisadores que necessitam compartilhar informações em um domínio. Algumas razões para se criar uma ontologia são:
Compartilhar um entendimento comum da estrutura da informação entre pessoas ou agentes de software;
Possibilitar o reuso do domínio de conhecimento;
Tornar explícitas hipóteses sobre o domínio;
Separar o conhecimento do domínio e o conhecimento do conhecimento operacional;
Analisar o domínio de conhecimento.
Não existe uma única metodologia correta para o desenvolvimento de ontologias, nem um único resultado correto. Desenvolver uma ontologia é, em geral, um processo interativo. Começa-se com um primeiro rascunho da ontologia. Então, essa primeira versão é refinada e detalhes são inseridos.
Em termos práticos, desenvolver uma ontologia inclui:
Definir classes da ontologia;
Arranjar as classes em uma hierarquia de subclasses e superclasses;
Definir slots e descrever os valores permitidos para eles;
Preencher os valores para os slots com instâncias.
Existem muitas possibilidades de ontologias para um determinado domínio; qualquer ontologia específica é apenas uma maneira de estruturas conceitos e relações. Existem alguns poucos princípio que podem ajudar a tomar decisões de projeto em muitos casos:
Não existe uma única maneira correta de modelar um domínio - sempre existem alternativas viáveis. A melhor solução quase sempre depende da aplicação que se está concebendo e nas previsão para seu uso;
O desenvolvimento de ontologias é, necessariamente, um processo interativo;
Conceitos em uma ontologia devem representar objetos (físicos ou lógicos) e relações do domínio de interesse. São muito provavelmente substantivos (objetos) ou verbos (relações) em sentenças que descrevem o domínio.
Pode-se começar determinando para que se pretende usar a ontologia, e o quanto detalhada ou geral a ontologia deve ser. Entre várias alternativas viáveis, deve-se determinar qual delas funcionará melhor para a tarefa imaginada, a mais intuitiva, mas extensível e a mais fácil de se manter. Uma ontologia é um modelo de um domínio real no mundo e os conceitos da ontologia devem refletir esse realidade.
Após definir uma versão inicial da ontologias, pode-se
avaliá-la e corrigi-la utilizando-a em aplicações ou em métodos de
solução de problemas (problem-solving methods), ou discutindo com especialistas da
área. Como resultado, quase sempre será preciso revisar a ontologia inicial.
Esse processo de projeto interativo continua através de todo o ciclo de vida
da ontologia.
Suponho que é preciso desenvolver um sistema que auxilia a gerencia custo e a organização de um jornal. A subpasta "examples/newspaper" do diretório de instalação do Protege contém um projeto completo, denominado newspaper, o qual fornece uma ontologia possível para esse domínio. Algumas questões que pode-se desejar responder são:
Quem é responsável para cada seção do jornal?
Qual é o conteúdo de cada artigo em uma seção, e quem é o autor?
A quem cada autor se reporta?
Qual é o layout e o custo de cada seção?
Uma vez que se tem uma idéia do que é preciso cobrir, pode-se listas alguns termos importantes que são necessários. Esses termos podem incluir conceitos básicos, propriedade que os conceitos devem ter e relações entre eles. Para começar, pode-se apenas coletar termos sem preocupação sobre o papel que eles vão desempenhar na ontologia.
No exemplo do jornal, tem-se seções. Cada seção contem conteúdo, tal como artigos e anúncios, e cada uma tem também um editor, que é responsável por cada seção. Cada artigo tem um autor, e aquele autor pode ter ou não um empregado. Para cada empregado, é preciso determinar o nome e o salário, e também a quem ele se reporta.
Ao continuar a gerar termos, se está implicitamente definindo o escopo da ontologia, ao definir o que se deve incluir ou excluir. Por exemplo, ao examinar preliminarmente o termo empregado, pode-se desejar adicionar zelador ou motorista. Entretanto, refletindo, pode-se perceber que a ontologia enfatize custos diretamente associados com a geração de conteúdo e a apresentação do jornal. Dessa forma, poder-se-ia decidir não incluir zelador como um termo de interesse.
Quando se tem uma lista suficientemente completa, pode-se iniciar o processo de categorizar diferentes termos, de acordo com sua função na ontologia. Conceitos que são objetos, tais como artigo ou autor, são provavelmente representados por classes. Propriedades das classes, tais como conteúdo ou salário, podem ser representados por slots; e restrições sobre as propriedades ou sobre relações entre classes ou slots, são representados por restrições sobre slots.
Em seguida, descreve-se como usar a interface do Protege para criar a estrutura desses componentes da ontologia.
Para criar um exemplo de projeto, siga as instruções:
Inicie o Protege. Se já existe um projeto do Protege
aberto, feche-o e reinicie o programa. Ao iniciar o Protege, a caixa de
diálogo de boas vindas é apresentada, para que se possa criar um novo
projeto, abrir um projeto recente ou obter ajuda.
Clique em Criar novo projeto... (Create New Project...). Uma caixa de diálogo será aberta, permitindo a escolha do tipo de projeto. A menos que seja necessário um tipo especial de formato para os arquivos, apenas clique em Terminar (Finish) para aceitar a definição padrão: "Protege Files (.pont and pins)".
A janela do Protege é aberta e as etiquetas (tabs) se
tornam visíveis. Um novo projeto sempre é aberto na visão de Classes.
As classes internas de sistema do Protege (:THING e :SYSTEM-CLASS) são
apresentadas. Não serão criadas instâncias.
Embora o tutorial não seja longo, pode-se desejar sair do projeto antes de terminá-lo. Salvar o projeto permite encerrar a atividade sempre que se ache conveniente. Para salvar o projeto:
Clique no botão "Salvar Projeto" (Save Project) 
(o terceiro da esquerda no menu superior do Protege).
Pode-se escolher também "Salvar Projeto" no menu
"Arquivo" (File). A caixa de diálogo de arquivos do Protege
(Protege
Files) será aberta.
Escolha a localização para salvar o projeto, clique no
botão 
a direita da linha "Projeto" (Project).
A caixa de diálogo de arquivos do Protege (Protege
Files), navegue para selecionar ou criar um diretório. 
A janela principal do Protege consiste de etiquetas (tabs) que apresentam vários aspectos do modelo de conhecimento. A etiqueta mais importante que aparece ao se iniciar um projeto é a etiqueta "Classes". Em geral, classes vão corresponder a objetos, ou tipos de objetos, no domínio. No exemplo do jornal, classes podem ser pessoas, tais como editores, repórteres e vendedores; componentes do layout do jornal, tais como seções; e conteúdo do jornal, tais como anúncios e artigos.
Classes no Protege são mostradas em uma hierarquia com heranças, apresentadas em um "Navegador de Classes" (Class Browser), do lado esquerdo da etiqueta "Classes". As propriedades da classe selecionadas na árvore, no momento, são apresentadas no "Editor de Classes" (Class Editor) à direita.
Nessa seção, o objetivo é ensinar como criar classes e subclasses, modificar a hierarquia de classes, criar classes abstratas, e adicionar superclasses adicionais a classes existentes.
Deseja-se acompanhar fonte de cada artigo, e assim, serão criados diferentes tipos de pessoas e serviços que originam artigos. Primeiro, vai-se criar uma nova classe denominada colunista (columnist):
Selecione a etiqueta de classes (Classes Tab).
Localize a área "Hierarquia de Classes" (Class Hierarchy)
no painel "Navegador de Classes" (Class Browser) do lado
esquerdo da janela do Protege. Essa área mostra a hierarquia de classes e
destaca a classe selecionada no momento.
Assegure-se de que a classe :THING está destacada.
Quase todas as classes que serão criadas estarão subordinadas a :THING. A classe :SYSTEM_CLASS
é usada para definir a estrutura de vários formulários do Protege.
Clique no botão Criar classe (Create Class)
, do na parte superior direita do "Navegador de
Classes". Uma classe é criada com um nome genérico, baseado no nome
do projeto, tal como "tutorial_Class_0". Pode-se ver o nome no
"Navegador de Classes" e, além disso, ele aparece destacado para
mostrar que está selecionado.
Digite Colunista (Columnist). Uma
convenção recomendável no Protege é criar o primeiro caráter de cada
palavra em um nome de classe, em maiúsculo, e o resto do nome em minúsculo,
além de separar as palavras por um traço baixo (underscore).
Tecle Enter ou clique de novo na classe destacada
para completar a operação e mostrar a alteração.
Caso ocorram problemas em renomear a classe,
verifique o painel Editor de Classes (Class Editor), do lado direito
da janela do Protege. O nome genérico da classe criada deve ser apresentado
e destacado no campo "Nome" (Name). Se o nome genérico
correto é mostrado, mas não destacado, apenas dê um clique duplo no campo
"Nome" para editar o nome. Se um nome incorreto é mostrado,
então a classe errada está selecionada na área de "Hierarquia de
Classes" (Class Hierarchy). Clique na classe que se deseja
renomear.
e digite Autor (Author).
e renomeie a nova classe como o nome Serviço_de_Noticias
(News_Service). Toda vez que uma nova classe for criada,
ela é criada como subclasse da classe destacada no momento. Note que quando
se cria a primeira subclasse de uma classe, um ícone 
ou 
aparece a sua esquerda. Pode-se usar esse
ícone para mostrar ou ocultar as subclasses de uma classe. Para que se
possa desenvolver a ontologia em seções posteriores, será criada outra
subclasse de Autor (Author). e renomeie a nova classe Editor.
Uma classe do Protege pode ser Concreta (Concrete), o que significa que ela pode ter instâncias diretas, ou pode ser Abstrata (Abstract), o que significa que ela aparece na hierarquia, mas não tem instâncias diretas. Quando se cria a primeira classe, ela é, por convenção, concreta. Agora que se sabe mais sobre a classe Autor (Author), percebe-se que qualquer instância de Autor vai realmente ser uma instância de um tipo particular de autor, tal como, por exemplo, um colunista ou um serviço de noticias. Dessa forma, vai-se alterar a classe Autor (Author) para uma classe abstrata. Para realizar essa tarefa:
Selecione Autor (Author) na
hierarquia de classes. No "Editor de Classes" (Class Editor), do
lado direito do "Navegador de Classes", localize o menu Papel
(Role), logo abaixo do nome da classe.
Clique no menu Papel (Role) e
selecione Abstrata (Abstract).
Note que quando se muda o papel da classe, o ícone em
frente ao nome da classe, no caso o nome "Autor", é alterado. O
novo ícone 
indica uma classe abstrata na hierarquia. Um ícone
sólido 
indica uma classe concreta.
Agora vai se criar outra classe, Empregado (Employee). Um Empregado (Employee) é qualquer empregado do jornal, que pode ser ou não um autor. Observe entretanto, que se está apenas interessado em empregado que estão envolvidos na criação e gestão do conteúdo do jornal. Uma das escolhas a tomar no projeto de uma ontologia é o que não considerar. Ao mesmo tempo que é necessário assegurar-se de que foram incluídos todos os conceitos relevantes, não se deve complicar a hierarquia adicionando classes que são dispensáveis. Dessa forma, mesmo que um zelador possa ser, tecnicamente, um empregado do jornal, não há interesse em criar uma subclasse chamada "zelador".
e renomeie a classe Empregado (Employee).
Conforme mencionado anteriormente, deseja-se que um Colunista (Columnist) seja um Empregado (Employee). Como a classe Colunista (Columnist) já está criada, não se deseja criá-la novamente. Ao invés disso, é possível fazer com que a classe Colunista (Columnist) existente seja uma subclasse de Empregado (Employee), da forma explicada a seguir:
Vá até o painel de superclasses na parte inferior
esquerda da janela do Protege, abaixo do "Navegador de Classes " (Class
Browser). Note que, quando Colunista (Columnist)
está selecionado, a superclasse atual de Colunista (Columnist),
que é Autor (Author), é apresentada no painel de
superclasses.
Clique no botão Adicionar Superclasse (Add Superclass) 
na parte superior direita no painel de superclasses.
Uma caixa de diálogo de "Selecionar Classes" (Select Classes)
será apresentada, mostrando todas as classes que foram criadas até agora,
organizadas em uma hierarquia.
Marque Empregado (Employee) e clique
em OK. O Colunista (Columnist) agora tem duas
superclasses: Autor (Author) e Empregado (Employee).
Ambas as superclasses são apresentadas no painel de superclasses.
Note que um ícone aparece do lado esquerdo de Empregado
(Employee). Clique nesse ícone para expandir o
"filho" (na hierarquia) de Empregado (Employee).
Colunista (Columnist) agora aparece em dois lugares no
"Navegador de Classes" (Class Browser): uma vez, abaixo de Autor
(Author) e, novamente, abaixo de Empregado (Employee).
Selecione Editor (Editor) no
"Navegador de Classes" (Class Browser).
Clique no botão do mouse, segure e arraste a
classe "Editor" para cima da classe Empregado (Employee).
Empregado (Employee) é destacado.
Antes de soltar o botão do mouse, pressione a tecla Ctrl,
e então solte o botão do mouse para transferir a subclasse.
Para remover uma superclasse de uma classe, marque a
superclasse que se deseja remover no painel Superclasses e clique no botão Remover
Superclasse (Remove Superclass) 
. Agora pode-se designar alguns atributos para as classes
já inseridas, criando-se slots. Esse assunto será tratado na próxima
seção.
Atributos de classes são descritos utilizando-se slots. Nas seções seguintes apresenta-se o processo de criar slots e atribuí-los a classes, a descrição de relacionamentos entre classes usando slots, e o funcionamento da herança de slots.
Existem várias formas de se criar um slot. Uma maneira é criar slots usando a "etiqueta slots" e, então, atribuí-lo a uma ou mais classes. Para criar uma slot denominado nome (name) dessa forma, faça:
Clique na "etiqueta slots".
Observe que essa etiqueta tem uma layout similar ao da "etiqueta
classes", com os slots listados a esquerda, e o "editor de
slots" mostrando as propriedades dos slots, a direita.
Clique no botão Criar slot (Create Slot) 
no lado direito superior do painel de
"hierarquia de slots" (Slot Hierarchy). Um novo slot
é criado. Assim que o slot é criado, recebe um nome genérico, tal
como "tutorial_Slot_0". Esse nome é automaticamente destacado no
"Editor de Slots" (Slot Editor).
Para nomear o slot, assegure-se de que o nome genérico
está destacado no campo nome (name) do "Editor de Slots"
(Slot Editor). Digite o nome do slot, que nesse caso, se chama
nome (name). Uma convenção recomendada é usar letras
minúsculas nomes de slots, com as palavras separadas por traços
baixos (underscores). Criar slots com nomes em letra
minúscula, e classes com nomes que se iniciam com letras maiúsculas,
facilita a distinção entre eles na ontologia.
Observe que esse slot tem string como "tipo de valor padrão" (default Value Type). O tipo de valor (Value Type) impõem restrições relativas aos tipos de valores que um slot pode ter. Um slot do tipo string recebe valores que são qualquer caractere alfanumérico, inclusive espaços.
Para esse slot simples, não vai-se alterar quaisquer outras facetas (restrições sobre os slots) no "Editor de Slots" (Slot Editor).
Tudo o que foi feito até aqui foi criar um slot que define o atributo geral nome (name). Para incorporá-lo a ontologia, é preciso atribuí-lo a uma classe, por exemplo: se deseja que cada instância da classe Autor (Author) tenha um nome.
Para fazer isso, retorna-se a "etiqueta Classes" (Classes Tab) e edita-se a classe Autor (Author). Quaisquer atributos criados ou atribuídos a uma classe são apresentados no "Editor de Classes" (Class Editor), a direita do "Navegador de Classes" (Class Browser). Já se utilizou o "Editor de Classes (Class Editor) para alterar o nome de classes criadas, e também para alterar o papel da classe Autor (Author) para abstrata. Agora, vai se utilizá-lo para ver e nomear slots.
Para atribuir o slot nome (name) a uma classe:
Destaque a classe Autor (Author) no painel de hierarquia
de classes (Class Hierarchy).
Durante um momento, observe o "Editor de
Classes" (Class Editor), à direita. Essa área tem um Nome (Name), o
qual foi alterado anteriormente para Autor (Author), o papel (Abstract),
além da documentação e restrições. Abaixo desse campo está o painel de
"Modelos de Slots" (Template Slots), o qual ocupa toda a metade
inferior do painel "Editor de Classes" (Class
Editor). Nessa área são listados todos os slots atribuídos a uma classe. No
momento, ela está vazia.
Para adicionar um slot a uma classe, clique no
botão Adicionar Slot (Add Slot) 
. Os botões de slots aparecem a direita da
janela do Protege, logo acima do painel de "Modelos de Slots" (Template Slots).
Quando se clica no botão Adicionar Slot (Add Slot),
a caixa de diálogo "selecionar modelos de slots" (Select Template Slots)
apresenta todos os slots do projeto atual, em ordem alfabética (com exceção
das classes de sistema do Protege, as quais são listadas abaixo
da hierarquia de slots).
Alternar entre a "etiqueta classes" (Classes Tab)
e a "etiqueta slots" (Slots Tab) pode ser cansativo.
Além disso, uma vez que slots representam propriedades de classes,
seria mais simples criar slots diretamente da "etiqueta
classes" (Classes Tab), o que é fácil fazer no Protege.
Para
criar um slot para a classe Empregado (Employee):
Clique no botão Criar Slot (Create Slot) no lado direito do painel "modelos de slots"
(Template Slots), o qual apresenta o formulário para preenchimento
de dados sobre o slot:
Retorne a janela principal (pode-se deixar caixa de
diálogo do editor de slots para salary aberta, caso se
deseje; vai-se retornar posteriormente a ela para editar mais propriedades
do slot salary). Observe que o slot agora
aparece no painel "modelos de slots" (Template Slots)
quando Empregado (Employee) é destacado.
Não é preciso atribuir o slot nome (name) a cada classe em que se deseja que ele apareça. Qualquer subclasse de uma classe automaticamente herda todos os slots da superclasse. Por exemplo, ao clicar na classe Serviço_de_Notícias (News_Service), pode-se ver que:
a) o slot nome (name) já foi
atribuído a essa classe através de herança;
b) o ícone do slot
está diferente de quando ele foi atribuído a Autor (Author),
ou seja, o ícone de "slot herdado" (inherited slot) 
mostra que esse slot foi atribuído por
herança.
Classes com mais de uma superclasse herdam slots
de todas as classes superiores. Por exemplo, ao clicar na classe Editor
(Editor), pode-se ver que ela herda o slot nome (name)
de Autor (Author), e o slot salário (salary)
de Empregado (Employee). A herança múltipla é uma
funcionalidade importante do Protege.
Os slots criados até aqui são bem simples. Entretanto, slots podem ter propriedades. Por exemplo, um "salário" (salary) é sempre um número. Pode-se também utilizar slots para criar relacionamentos entre as classes. As propriedades de um slot, chamadas facetas (facets), podem ser criadas e editadas a partir "etiqueta classes" (Classes Tab) usando o diálogo de especificação de slots, ou a partir da "etiqueta slots" (Slots Tab) no painel "editor de slots" (Slot Editor).
Dê um clique duplo no slot salário (salary)
no painel "modelos de slots" (Template Slots) para a abrir
o formulário de slots. É apresentada uma caixa de diálogo
solicitando que seja selecionada a "visão do slot" (Slot View).
Ao editar um slot, pode-se escolher se as mudanças serão aplicadas
ao slot e a todas as classes relacionados a esse slot --
"slot de nível superior" (top level slot) -- ou
apenas a classe corrente e todas as suas classes filhas, ou seja, de nível
inferior na hierarquia.
Nesse caso, deseja-se ver e editar o "slot de
nível superior" (top-level slot). Assegure-se que a opção
"visão do slot de nível superior" (View top-level slot)
está selecionada e clique em OK. Essa ação vai alterar a
definição do slot em qualquer lugar que ele apareça na ontologia.
No formulário de slots resultante, selecione Flutuante
(Float) no menu Tipo de valor (Value Type),
a esquerda. Ao criar instâncias, será possível fornecer apenas números
decimais para esse slot.
Entre com 0 (zero) no campo "mínimo" (Minimum)
na parte inferior esquerda. Essa ação especifica que, para casa instância
de Empregado (Employee), o valor que será atribuído ao
salário (salary) deve ser positivo.
Feche a caixa de diálogo de edição de slots.
Pode-se ver que a descrição do slot foi alterada no painel
"modelos de slots" (Template Slots). O tipo agora
está configurado como "Flutuante" (Float), e o valor
mínimo de 0.0 aparece na coluna "outras facetas" (Other Facets).
O Protege também permite criar slots que podem ser utilizados para descrever relacionamentos entre classes, os quais não foram definidos na hierarquia de classes. Isso pode ser feito usando slots do tipo "instância" (instance) ou do tipo "classe" (class). Por exemplo, um editor pode ser "responsável por" (responsible for) um ou mais empregados. Pode-se criar um slot que representa esse relacionamento entre Editor (Editor) e Empregado (Employee), da seguinte maneira:
para criar um novo slot a para Editor (Editor). 
Selecione "instância" (Instance) no
menu "tipo de valor" (Value Type).
Um novo campo, "classes permitidas" (Allowed
Classes), é apresentado abaixo do menu do menu "tipo de
valor" (Value Type).
Clique no botão "adicionar classe" (Add Class)
que aparece na parte superior direita da área de "classes
permitidas" (Allowed
Classes). Surge uma caixa de diálogo para "selecionar classes"
(Select Classes), apresentando todas as classes do projeto.
Selecione Empregado (Employee) e clique em OK.
Para permitir que um editor seja responsável por mais de
um empregado, clique na opção "múltiplo" (multiple) na
área de "cardinalidade" (Cardinality), do lado direito da
área de "tipo de valor" (Value Type).
Após completar os passos de 1 a 6, o slot responsável
por (responsible_for) deve estar com a seguinte
configuração:
O que realmente foi feito? Foi criado um slot
que abrangeu uma ou mais instâncias da classe Empregado (Employee)
com seus valores. Mais tarde, ao se criar uma instância da classe Editor
(Editor), será preciso especificar por quem o editor é
responsável, e poderá se escolher uma ou mais instâncias da classe Empregado
(Employee) para preencher o valor do slot Responsável
por (responsible_for).
Instâncias são os dados reais da base de conhecimento. Uma boa idéia é assegurar-se de que o projeto foi bem estruturado, antes de inserir um grande número de instâncias. Caso sejam necessárias alterações na estrutura das classes ou slots após a inserção das instâncias, pode ocorrer perda de informação. Além disso, caso se adicionem outros slots, será necessário voltar e preencher os valores de slots para todas as instâncias criadas anteriormente.
Nessa seção, vai-se criar duas instâncias para a classe Editor (Editor):
Clique na "etiqueta instâncias" (Instances
Tab). Essa etiqueta tem três painéis. O primeiro, do lado esquerdo,
apresenta a hierarquia de classes (class hierarchy). O painel do
meio, o qual aparece em branco, apresentará a lista de instâncias a serem
criadas para uma classe específica. O terceiro painel corresponde ao
"editor de instâncias" (Instance Editor), o qual apresenta
o formulário para a instância marcada no momento, na qual serão inseridos
valores de slots.
para expandir as subclasses de Empregado
(Employee).Clique em Editor (Editor). O botão Criar
instância (Create Instance) 
no "navegador de instâncias" (Instance Browser)
se torna ativo, indicando que pode-se agora criar uma instância.
Clique no botão Criar instância (Create Instance) . Uma instância é criada, e o formulário do
"editor de instâncias" (Instance Editor) aparece. Pode-se
observar que existem campos, um para cada slot criado anteriormente.
Esses campos devem ser usados para inserir valores para os slots.
Note que no painel "hierarquia de classes" (Class Hierarchy),
a apresentação da classe Editor (Editor) foi alterada
quando se criou a instância. O número "um" entre parênteses (1),
após a classe Editor (Editor), indica que aquela classe agora
possui uma instância.
Entre com o valor 150000 no campo Salário
(Salary). Observe que os caracteres nesse campo vão aparecer
em vermelho, se outro valor que não seja um valor flutuante (float)
válido for inserido (no Protege, a tentativa de inserir valores que não
satisfaçam as restrições determinadas para o slot, fará com que
esse valor seja apresentado em vermelho).
A "etiqueta instâncias" (Instances Tab) agora,
deve parece com a figura abaixo. Observe que a instância ainda tem um nome
genérico no Navegador de Instâncias (Instance Browser), tal como "tutorial_instance_0".
Na próxima seção, será explicado como alterar essa situação.
Para criar uma outra instância:
Clique no botão Criar instância (Create Instance) no "navegador de instâncias" (Instance
Browser).
Agora que se criaram algumas instâncias, pode-se definir um relacionamento entre elas, por exemplo, pode-se dizer que Chief Honcho é "responsável por" (responsible for) Mr. Science. Antes de fazer isso, de forma a tornar o trabalho com as instâncias mais simples, vai-se configurar um "slot de apresentação" (display slot) para a classe Editor (Editor). O Protege apresenta o valor do "slot de apresentação" cada vez que forem apresentadas as instâncias da classe. A configuração desse slot é explicada na próxima seção.
Para cada classe da ontologia, pode-se especificar um de seus slots para ser um "slot de apresentação" (display slot). O Protege vai apresentar o valor desse slot cada vez que apresentar instâncias da classe. Caso não se configure um "slot de apresentação", o Protege apresenta um nome gerado pelo sistema para o slot, tal como "tutorial_Instance_0". Assim, é útil configurar um "slot de apresentação" para todas as classes que terão instâncias. De fato, pode-se escolher configurar esses slots para as classes antes mesmo de começar a criar instâncias.
Para configurar um "slot de apresentação" (display slot) para a classe Editor (Editor):
Nessa seção, a instância Chief Honcho será modificada para torná-lo responsável pelo Mr. Science:
Clique na "etiqueta de instâncias" (Instances
Tab), clique no ícone para expandir a classe Empregado (Employee)
no painel "hierarquia de classes" (Class
Hierarchy), e selecione a classe Editor (Editor).
Instâncias de Editor são agora listadas no "navegador de
instâncias" (Instance Browser).
Selecione Chief Honcho no "navegador de
instâncias" (Instance Browser). Serão apresentados os slots
para Chief Honcho no formulário do "editor de instâncias"
(Instance Editor), inclusive o slot Responsável Por (Responsible For).
Note que o Protege usa o slot "nomes" (names) no
formulário de instâncias, mas automaticamente converte os traços baixos (underscores)
para espaços e torna maiúscula a primeira letra de cada palavra.
Clique no botão Adicionar Instância (Add Instance) 
do lado direito superior do campo Responsável por
(Responsible For).
Para cada classe na ontologia, o Protege gera um formulário padrão que pode ser utilizado para inserir dados, ou seja, instâncias. Os formulários (forms) contém um campo de entrada de dados, denominado "forma gráfica" (widget), para cada slot relacionado a uma classe. Existem diferentes tipos de "formas gráficas" (widgets), para manipular os vários tipos de valores de slots. Por exemplo, o Protege atribui um widget denominado "InstanceListWidget" a slots com tipos de valores "instância" (instance) e cardinalidade múltipla.
Caso não se queira utilizar o formulário padrão que o Protege gera para uma classe, pode-se personalizá-lo através da "etiqueta formulários" (Forms Tab). Dentre outras possibilidades, pode-se redimensionar widgets, arrastá-los para outros locais do formulário, ocultá-los, e mesmo selecionar diferentes tipos de widgets.
Para ver como as mudanças que serão realizadas na "etiqueta formulários" (Forms Tab) nas próximas seções refletem no "editor de instâncias" (Instance Editor), vá até o "editor de instâncias" (Instances Tab), e dê um clique duplo sobre Chief Honcho no "navegador de instâncias" (Instance Browser) para apresentar uma janela separada do "editor de instâncias" (Instance Editor). Observe que se foram criados slots para a classe Editor de forma diferente daquela explicada nesse tutorial, o formulário pode não ser apresentado exatamente igual as figuras das seções seguintes.
Assegure-se de que Editor está selecionado no
"navegador de formulários" (Form Browser), a esquerda. Em
seguida, selecione o tipo de widget denominado "FloatFieldWidget"
para o slot salário (salary), clicando sobre
ele no "editor de formulários" (Form Editor), do lado
direito da tela. Esse widget é então destacado com uma linha
de contorno verde, que confirma que ele foi selecionado. Observe que a
caixa tipo combo box denominada "tipo de forma gráfica
selecionada" (Selected Widget Type), do lado superior direito,
informa que se trata de uma "forma gráfica para campo flutuante"
(FloatFieldWidget), a qual é um widget usado para entrada de
números com ponto flutuante.
Clique sobre o lado direito do widget e arraste
para aumentar seu tamanho. Tente alinhar o lado direito desse widget
com o lado direito do widget do slot nome (name).
Observe que o ícone em frente a Editor no
"navegador de formulários" (Form Browser) foi alterado. O
novo ícone 
indica que o formulário para essa classe
foi personalizado.
Arraste-o para a parte superior direita do formulário,
de forma que a linha superior do widget se alinhe como a linha
superior do widget para o slot nome (name).
Pode-se personalizar formas gráficas (widgets) de forma que apresentem um título diferente, ou mesmo um conjunto de botões diferente do padrão. Por exemplo, pode-se desejar ter a possibilidade de apagar uma instância do projeto clicando em um botão na "InstanceListWidget", que foi atribuída ao slot responsável_por (responsible_for). Para apresentar o botão de apagar:
Dê um clique duplo no "InstanceListWidget"
denominado Responsável Por (Responsible For) no
"editor de formulários" (Form Editor).
Clique na caixa de seleção em frente de "Mostrar
botão de apagar instância" (Show Delete Instance Button) para
selecionar essa opção.
Clique em OK. A "forma gráfica para lista de
instâncias" (InstanceListWidget) para o slot responsável_por
(responsible_for) tem agora cinco botões.
Pode-se ocultar uma "forma gráfica" (widget) para que ela não possa ser vista no "editor de formulários" (Form Editor) e no "editor de instâncias" (Instance Editor). Essa ação não remove qualquer informação da ontologia. Por exemplo, pode-se ocultar o widget para o slot salário (salary). Para fazer isso:
Selecione a "forma gráfica para campo
flutuante" (FloatFieldWidget) denominado Salário (Salary)
no "editor de formulários" (Form Editor).
Selecione "<none>" para a caixa combo box
"tipo de forma gráfica selecionada" (Selected Widget Type).
A "forma gráfica" (widget) para o slot
salário (salary) não está mais visível no
"editor de formulários" (Form Editor).
, do lado direito superior.
Na caixa de diálogo "configurar formulário" (Configure form),
pode-se ver uma lista de todos os slots e suas formas gráficas
correspondentes.
Clique em "<none>" na coluna do lado direito, ao
lado de salário (salary), para apresentar diferentes
opções de widgets para esse slot, e selecione "forma
gráfica de ponto flutuante" (FloatFieldWidget).
Caso as personalizações realizadas não atendam as expectativas, o Protege permite rearranjar rapidamente todos as "formas gráficas" (widgets) visíveis de acordo com o layout padrão, acomodando o tamanho atual de cada widget.
Para que o Protege organize automaticamente todas as "formas gráficas" (widgets) de acordo com o layout padrão:
, do lado superior direito do "navegador
de formulários".
.A "etiqueta de consultas" (Queries Tab) permite que sejam realizadas consultas no projeto e que se recuperem todas as instâncias que atendam a critérios específicos. Para criar uma consulta (query), deve-se selecionar uma ou mais classes, e um ou mais slots dessas classes. Pode-se também salvar as consultas na "biblioteca de consultas" (Query Library) para utilização futura.
Considere-se que se deseja localizar todos os empregados que tem um salário superior a $75,000 por ano. Para criar uma consulta:
Clique no botão Selecionar Classes (Select Cls) acima da caixa de texto para classes (class),
no painel de consultas (Query pane).
acima da caixa de texto para Slots.Selecione salário (salary) na caixa
de diálogo "selecionar slot" (Select Slot) e clique
OK.
O menu do lado direito da caixa de texto de slots
está agora ativo, e a caixa de texto mais a direita da janela relembra que
o tipo de valor do slot selecionado é "ponto flutuante" (float).
Selecione "é maior que" (is greater than)
no menu suspenso (drop down menu). Em seguida, entre com o valor "75000"
na caixa de texto Float.
Para executar a consulta, clique no botão
"encontrar" (Find), na parte inferior direita do
"painel de consultas" (Query pane).
Os resultados são mostrados no painel de
"resultados de busca" (Search Results), do lado direito da
tela. Caso não seja possível ver os resultados, será preciso aumentar a
janela ou mover a barra que separa o painel.
Pode-se salvar qualquer consulta antes ou depois que ela for executada. Para salvar uma consulta na "biblioteca de consultas" (Query Library):
Clique no botão Adicionar a Biblioteca de consultas
(Add to Query Library) 
, do lado direito da caixa de texto "nome da
consulta" (Query Name).
Digite "sample_query" na caixa de diálogo "entrar
com o nome da consulta" (Input Query Name).
Clique OK. O nome é apresentado na caixa de texto
"nome da consulta" (Query Name) e a consulta é listada no
painel "biblioteca de consultas" (Query Library) na parte
de inferior da tela.
Para recuperar um consulta salva, ela deve ser selecionada na "biblioteca de consultas" (Query Library):
Em primeiro lugar, porque se está executando uma mesma
consulta novamente, clique no botão "limpar" (Clear) para
limpar os resultado de consulta. Caso contrário, não será possível
visualizar a alteração.
Selecione "sample_query" na
"biblioteca de consultas" (Query Library) na parte inferior
da tela. Caso não seja possível ver a "biblioteca de consultas"
( Query Library), será preciso aumentar a janela ou mover a barra de
separação.
para recuperar a consulta escolhida.A consulta salva é agora apresentada na parte superior
da janela. Caso desejado, pode-se nesse momento, alterar a consulta. Pode-se
também combinar consultas clicando no botão Mais (More).
