universidade do vale do itajaÍ centro de ciÊncias ...siaibib01.univali.br/pdf/alisson...
TRANSCRIPT
UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
DESENVOLVIMENTO DE UM AGENTE PEDAGÓGICO UTILIZANDO JCLIPS
Área de Inteligência Artificial
por
Alisson Oldoni
Anita Maria da Rocha Fernandes, Dra. Orientadora
Janice Inês Deters, M. Sc. Co-orientadora
Itajaí (SC), novembro de 2006
UNIVERSIDADE DO VALE DO ITAJAÍ CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
DESENVOLVIMENTO DE UM AGENTE PEDAGÓGICO UTILIZANDO JCLIPS
Área de Inteligência Artificial
por
Alisson Oldoni Relatório apresentado à Banca Examinadora do Trabalho de Conclusão do Curso de Ciência da Computação para análise e aprovação. Orientadora: Anita Maria da Rocha Fernandes, Dra.
Itajaí (SC), novembro de 2006
ii
DEDICATÓRIA
Dedico este trabalho a todos que, de alguma forma, me ajudaram no desenvolvimento deste
trabalho, principalmente ao meu pai Vilmar Oldoni, a minha mãe Maria Telma Oldoni e a minha
irmã Larissa Oldoni. Eles são a minha família e eu os amo muito.
iii
AGRADECIMENTOS
Agradeço inicialmente a minha família que me ajudou desde o início deste curso, sempre me
apoiando, e que teve principalmente paciência comigo no desenrolar do desenvolvimento deste
TCC. Eu não poderia ter nascido no meio de uma família mais querida. Agradeço ao famoso Seu
Vilmar (meu pai), que levava os sucos e sanduíches nos momentos mais oportunos. Mesmo que às
vezes eu estava completamente concentrado e nem falava “obrigado”, eu ficava muito agradecido, é
sério! Não só por isso, claro, mas por tudo que ele fez na minha vida, me apoiando em tudo.
Principalmente na música: uma das minhas paixões. Agradeço a Dona Telma (minha mãe), a
melhor pessoa do mundo, que fazia a logística da minha vida enquanto eu tava ocupado com este
trabalho: marcando hora nos médicos, fazendo aquele rango esperto, entre todas as tarefas de mãe.
Agradeço a Mariá Dufloth Pelissa e a toda a sua família (incluindo animais de estimação).
Mariá é a minha namorada, companheira e amiga, a quem eu amo muito e que dá brilho a minha
tímida existência. Ela, durante todo o tempo, deu todo o apoio, seja ele psicológico ou não, no
estilo: “Alisson, é claro que você consegue!”. Ela é minha base de sustentação, a pessoa a quem
mais procuro para conselhos e opiniões no sobre a minha vida, que faz de tudo pra eu não me
estressar com as coisas do dia-a-dia e que ainda me faz comida (percebam que eu como bastante).
Agradeço a Professora Anita (minha orientadora e segunda mãe) que, apesar de brigar
comigo todo dia, sempre fazia tudo pelo meu bem. Se for parar pra pensar, eu merecia bem mais
xingões dos que eu levei. Ela é muito querida e atenciosa! Agradeço ao pessoal do IEB, aos
companheiros de projeto (desculpem se esqueci alguém): Janice, Marcos, Luciana (que me deu 32
apelidos ao longo da minha vida acadêmica) e Vander. Aos colegas de laboratório: Ricardo, Bruno
(representa!), Maylla, Guilherme, Vinicius, Rudimar, Marlei, Heitor, Poolney (culpa do Poolney!),
Crispim, Benjamin e Rafael (o único Corinthiano no meio de tantos São Paulinos). Agradeço
também aos meus professores e os muitos colegas de faculdade (os que eu lembro agora): Elias,
Santiago, Higor, Sidnei, Alôncio, Douglas, Deivid e Armando.
Agradeço aos meus colegas (na verdade melhores amigos) de banda: Rodrigo, Rafael,
Fabiano e Galego. Ao pessoal das minhas bandas: Contra, Garden All e Hot Spot, que sempre
entenderam caso faltasse algum ensaio ou coisa parecida. Agradeço também aos meus amigos(as)
de sempre: Morandi, Cristiano, André, Cadore, Vinicius, Filipi, Maria (que trouxe meu contrabaixo
novo de avião!), Briane, Pinha e Camila.
iv
SUMÁRIO
LISTA DE ABREVIATURAS................................................................vi
LISTA DE FIGURAS ............................................................................vii
LISTA DE TABELAS...........................................................................viii
RESUMO................................................................................................. ix
ABSTRACT..............................................................................................x
1 INTRODUÇÃO....................................................................................1 1.1 PROBLEMATIZAÇÃO................................................................................... 2 1.1.1 Formulação do problema............................................................................... 2 1.1.2 Solução proposta ............................................................................................ 3 1.2 OBJETIVOS ..................................................................................................... 3 1.2.1 Objetivo geral ................................................................................................. 3 1.2.2 Objetivos específicos ...................................................................................... 3 1.3 METODOLOGIA............................................................................................. 4 1.4 ESTRUTURA DO TRABALHO ..................................................................... 4
2 FUNDAMENTAÇÃO TEÓRICA ......................................................6 2.1 INFORMÁTICA NA EDUCAÇÃO (IE)......................................................... 6 2.1.1 Histórico da IE ............................................................................................... 6 2.1.2 Taxonomia ...................................................................................................... 7 2.2 STI .................................................................................................................. 9 2.2.1 Histórico dos STI.......................................................................................... 11 2.2.2 Arquitetura clássica dos STI ....................................................................... 12 2.3 AGENTES INTELIGENTES ........................................................................ 15 2.3.1 Características dos agentes inteligentes ...................................................... 16 2.3.2 Arquiteturas de agentes ...............................................................................20 2.3.3 Taxonomia de agentes ..................................................................................25 2.3.4 Agentes de interface ..................................................................................... 27 2.3.5 Agentes de interface pedagógicos ................................................................ 29 2.3.6 Arquitetura de STI utilizando agentes........................................................ 32 2.3.7 Exemplos de STI utilizando agentes............................................................ 34 2.4 SISTEMA ESPECIALISTA (SE) .................................................................. 36 2.4.1 Shells estudadas............................................................................................ 39 2.4.2 Ferramenta escolhida................................................................................... 41 2.4.3 Algoritmo de Rete ........................................................................................ 42
3 DESENVOLVIMENTO....................................................................45 3.1 PORTAL SAÚDE+EDUCAÇÃO .................................................................. 45 3.2 STI E AGENTE PEDAGÓGICO .................................................................. 47 3.3 CONCEPÇÃO VISUAL DO AGENTE PEDAGÓGICO ............................ 47
v
3.4 FUNCIONAMENTO DO AGENTE ............................................................. 48 3.5 IMPLEMENTAÇÃO ..................................................................................... 50 3.6 CRIAÇÃO DAS REGRAS............................................................................. 62 3.7 DIAGRAMAS................................................................................................. 68
4 CONCLUSÕES..................................................................................71
REFERÊNCIAS BIBLIOGRÁFICAS..................................................73
vi
LISTA DE ABREVIATURAS
CAI Computer Aided Instruction CGI Common Gateway Interface CLIPS C Language Integrated Production System FINEP Financiadora de Estudos e Projetos FORTRAN Formula Translator GNU GNU is Not Unix GPL General Public License GPS Global Positioning System HTML Hyper Text Markup Language HMD Head-Mounted Display HTTP Hypertext Transfer Protocol IA Inteligência Artificial ICAI Intelligent Computer Aided Instruction IE Informática na Educação IEB Instituto de Engenharia Biomédica ILE Integrated Learning Environments IP Internet Protocol JAR Java ARchive JCLIPS CLIPS for Java JDBC Java Database Connectivity JEOPS Java Embedded Object Production System JESS Java Expert System Shel JSP Java Server Pages JSF Java Server Faces LISP List Processing NASA National Aeronautics and Space Administration MCT Ministério da Ciência e Tecnologia OpenSUSE Open Software und System Entwicklung PEAS Performance, Environment, Actuators, Sensors SBIE Simpósio Brasileiro de Informática na Educação SE Sistema Especialista SMAR Sistema Multi-Agente Reativo STI Sistemas Tutores Inteligentes SWF Small Web Format TCC Trabalho de Conclusão de Curso UCB Universidade Católica de Brasília UFSC Universidade Federal de Santa Catarina UML Unified Modeling Language UNIVALI Universidade do Vale do Itajaí WIN Workshop de Informática Médica WWW World Wide Web XML eXtensible Markup Language
vii
LISTA DE FIGURAS
Figura 1. Arquitetura clássica de um STI .......................................................................................13 Figura 2. Arquitetura ampliada do STI...........................................................................................14 Figura 3. Agentes interagem com ambientes por meio de sensores e atuadores ..............................16 Figura 4. Pseudocódigo de um agente reativo simples....................................................................21 Figura 5. Diagrama esquemático de um agente reativo simples......................................................22 Figura 6. Pseudo-código de um agente reativo baseado em modelo................................................22 Figura 7. Um agente reativo baseado em modelo ...........................................................................23 Figura 8. Um agente baseado em modelos e orientado para objetivos ............................................24 Figura 9. Um agente baseado em modelo e orientado para utilidade...............................................24 Figura 10. Taxonomia de agentes baseada no mundo natural .........................................................25 Figura 11. Uma parte da tipologia de agentes multidimensional.....................................................27 Figura 12. Classificação multidimensional completa......................................................................27 Figura 13. Como os agentes de interface funcionam ......................................................................28 Figura 14. Arquitetura baseada em agentes ....................................................................................33 Figura 15. STI com arquitetura usando agente ...............................................................................34 Figura 16. O agente Adele, explicando a importância de certos procedimentos..............................35 Figura 17. O agente Guilly.............................................................................................................36 Figura 18. Sistema Especialista......................................................................................................38 Figura 19. Unificação de padrões: fatos e regras ............................................................................42 Figura 20. Recursos computacionais desnecessários quando as regras procuram fatos ...................43 Figura 21. Fatos em busca de regras ..............................................................................................43 Figura 22. Organização simplificada do projeto .............................................................................46 Figura 23. O agente “Bernardo”.....................................................................................................48 Figura 24. Arquitetura do agente “Bernardo”.................................................................................49 Figura 25. Organização do assunto ................................................................................................51 Figura 26. STI e o agente Bernardo ...............................................................................................52 Figura 27. Feições do agente Bernardo ..........................................................................................54 Figura 28. Tela de login e senha ....................................................................................................59 Figura 29. Agente explicando o ambiente ......................................................................................60 Figura 30. Itens do STI ..................................................................................................................61 Figura 31. Auto-avaliação..............................................................................................................61 Figura 32. Agente interagindo com o aluno....................................................................................62 Figura 33. Árvore de decisões do sistema especialista....................................................................64 Figura 34. Regras do sistema especialista ......................................................................................67 Figura 35. Regras do sistema especialista ......................................................................................67 Figura 36. Diagrama contendo os módulos do sistema ...................................................................68 Figura 37. Diagrama de seqüência .................................................................................................69 Figura 38. Diagrama do banco de dados ........................................................................................70
viii
LISTA DE TABELAS
Tabela 1. Exemplos de tipos de agentes e suas descrições de PEAS...............................................19 Tabela 2. Características de agentes pedagógicos baseados em objetivos .......................................31 Tabela 3. Comparação das shells...................................................................................................41 Tabela 4. Tabela de alunos.............................................................................................................56 Tabela 5. Tabela de acessos dos alunos..........................................................................................56 Tabela 6. Tabela de itens ...............................................................................................................57 Tabela 7. Tabela de questões .........................................................................................................57 Tabela 8. Tabela de tópicos ...........................................................................................................57 Tabela 9. Desempenho do aluno ....................................................................................................63
ix
RESUMO
OLDONI, Alisson. Desenvolvimento de um agente pedagógico utilizando JCLIPS. Itajaí, 2006. 129 f. Trabalho de Conclusão de Curso (Graduação em Ciência da Computação)–Centro de Ciências Tecnológicas da Terra e do Mar, Universidade do Vale do Itajaí, Itajaí, 2006. Dentre os recursos computacionais aplicados à educação explorados atualmente, tem-se os Sistemas Tutores Inteligentes. Uma das abordagens modernas para este tipo de sistema é a que faz uso do conceito de agentes inteligentes. Estes agentes são denominados pedagógicos quando estão ligados a um ambiente de ensino, como os Sistemas Tutores Inteligentes. Este projeto apresenta o estudo de caso do desenvolvimento de um agente pedagógico de interface inteligente para um Sistema Tutor Inteligente de neurofisiologia desenvolvido dentro do projeto “Sistemas Virtuais de Ensino Baseados na Internet para Suporte à Educação e Treinamento na Área da Saúde” do Instituto de Engenharia Biomédica da Universidade Federal de Santa Catarina. Este agente tem sua inteligência modelada através de sistemas especialistas e foi implementado utilizando o JCLIPS, biblioteca Java que faz uma conexão entre o Java e o software CLIPS. Para isso foram necessárias as seguintes etapas: análise do modelo conceitual do Sistema Tutor Inteligente; análise e programação da conexão entre JCLIPS e o PostgreSQL, que foi o sistema gerenciador de banco de dados utilizado no projeto; estabelecimento das variáveis do Sistema Tutor Inteligente que o agente pedagógico faz uso; criação da árvore de decisões do sistema especialista; validação das regras de produção geradas pela árvore de decisões; implementação das regras de produção no JCLIPS; e realização de testes do agente pedagógico dentro do contexto de uso do Sistema Tutor Inteligente. A entrega das feições do agente ao navegador Web foi feita utilizando um filme em Macromedia Flash, com uma comunicação com o navegador através de Javascript e com o servidor através de requisições a arquivos JSP. O JCLIPS é acessado pelo JSP e a quantidade de regras de produção necessárias para que o sistema especialista funcione adequadamente são definidas pelo conteúdo que foi abrangido e pela quantidade de classes de desempenho existentes para o aluno. Palavras-chave: Agentes Pedagógicos. Sistemas Tutores Inteligentes. JCLIPS.
x
ABSTRACT
Among the computational resources applied to the education currently explored, there are the Intelligent Tutoring Systems. One of the modern approaches for this kind of system it’s one that makes use of the intelligent agents concept. These agents are called pedagogical agents when connected to a learning environment, like the Intelligent Tutoring Systems. This project introduces the case study of the development of an intelligent interface pedagogical agent for a neurophysiology Intelligent Tutoring System developed inside the “Web Based Virtual Education Systems to Support Education and Training in Heath Area” project, coordinated by the Instituto de Engenharia Biomédica, an institute inside the Universidade Federal de Santa Catarina. The agent’s intelligence is modeled using expert systems and was implemented using JCLIPS, a Java library that makes a bridge between Java and the CLIPS software. For this project’s conclusion, the following steps were necessary: conceptual model of the Intelligent Tutoring System analysis; JCLIPS and PostgreSQL (the database management system used in this project) connection analysis and programming; establishment of the Intelligent Tutoring System variables that the pedagogical agent will make use of; creation of the decision trees for the expert system; decision trees’ generated production rules validation; production rules implementation using JCLIPS; and tests realizations using the pedagogical agent in the Intelligent Tutoring System context. The media content of the agent was delivered to the Web browser using a Macromedia Flash film, with a communication with the browser through Javascript and with the server through requisitions to JSP files. The JCLIPS is accessed by the JSP and the amount of production rules necessary to the system to work adequately are defined by the enclosed content and by the quantity of performance levels needed for the student. Keywords: Pedagogical agents. Intelligent Tutoring Systems. JCLIPS.
1 INTRODUÇÃO
O atual uso da informática na educação faz muitos recursos de aprendizado em uma
sociedade onde é necessário a constante presença de tecnologias de comunicação e informação.
Essas tecnologias possibilitam a inovação, a interação, a troca e a pesquisa em inúmeros segmentos
do conhecimento humano.
O processo de ensino tem sido revolucionado pela inserção da tecnologia. Dentro das
características percebidas com esta inserção, pode-se citar: a otimização de recursos, a melhora do
processo de ensino-aprendizagem, uma educação mais eqüitativa, a geração de uma formação
contínua, e uma melhor sintonia da escola com a sociedade (BRUNER, 2000 apud VILLAREAL,
2003).
Dentre os recursos educacionais explorados atualmente, tem-se os Sistemas Tutores
Inteligentes (STI). Tais sistemas têm a tendência moderna de fazer uso do conceito de agentes
pedagógicos inteligentes (BIGUS e BIGUS, 2001). Nissen (1995 apud COSTA, 1999) apresenta
uma idéia mais informal do que seriam agentes inteligentes, dizendo que “um agente é alguma coisa
que atua como um procurador com o propósito específico de realizar ações que podem ser
entendidas como benéficas à parte representada”. Outra definição é a de Shoham (1997 apud
COSTA, 1999) que mostra o agente como sendo uma “entidade de software funcionando
continuamente e de forma autônoma em um ambiente particular, freqüentemente habitado por
outros agentes e processos”.
Pereira e Geyer (1999) falam que os agentes são denominados pedagógicos quando estão
ligados a um ambiente onde existe uma sociedade de agentes que compõem um sistema de ensino-
aprendizagem. Estes agentes pedagógicos, no intuito de melhor interagir com o aluno, aparecem
como agentes gráficos animados de interface, que são personagens geralmente animados como
personagens de desenho animado em 2D ou 3D. Eles aparentam vida e são utilizados como
ferramentas cognitivas para dar suporte ao aprendizado do aluno (AHMED, KASSIM e
RANGANATH, 2001). Os agentes pedagógicos possuem um conjunto de regras que determinam os
objetivos de ensino e os planos para atingí-los. Estes planos são determinados pelo uso de
estratégias de ensino.
2
Dentro deste contexto, este projeto implementou um agente pedagógico cuja “inteligência”
foi modelada através de Sistemas Especialistas (SE). A ferramenta de SE utilizada foi o JCLIPS,
que fez a ligação do CLIPS (C Language Integrated Production System) com o Java. O agente e a
arquitetura desenvolvida foram utilizados dentro do STI de neurofisiologia, do portal
Saúde+Educação do projeto “Sistemas Virtuais de Ensino Baseados na Internet para Suporte à
Educação e Treinamento na Área de Saúde”.
1.1 PROBLEMATIZAÇÃO
1.1.1 Formulação do problema
Atualmente na área de Neurofisiologia identifica-se uma defasagem de conteúdos on-line,
principalmente na língua portuguesa, o que levou a construção de um STI que disponibilize
conteúdos desta natureza. Porém, pela grande abrangência dos conteúdos do STI, o aluno pode ter
dificuldades em guiar sua leitura. O STI então poderá perder um pouco seu potencial pedagógico
caso não tenha um guia especialista para o conteúdo, problema que pode ser corrigido através de
um agente pedagógico inteligente. O agente entra, então, como mediador do conteúdo, orientando o
aluno em como ele deve proceder nos seus estudos.
Dowling (2000) afirma que agentes pedagógicos são agentes autônomos que apóiam o
aprendizado humano, interagindo com os estudantes no contexto de ambientes de aprendizado
interativos. Eles ampliam e melhoram o trabalho sobre STI de várias formas. São capazes de
adaptar seu comportamento de acordo com o estado dinâmico do ambiente, tendo a vantagem de
buscar as oportunidades de aprendizado assim que elas surgem. Podem apoiar tanto o aprendizado
colaborativo quanto o individualizado, pois múltiplos estudantes e agentes podem interagir num
ambiente compartilhado.
Outro aspecto do problema é a integração das tecnologias usadas. Por ser um sistema on-
line, o STI necessita tecnologias que controlem a animação do agente, os acessos do usuário, a
disponibilização de conteúdo, o acesso a banco, o processamento no servidor e a Inteligência
Artificial (IA) do agente. Além disso, as tecnologias existentes no servidor devem utilizar software
livre, por restrições do projeto no qual este TCC está inserido.
Sendo assim, este trabalho desenvolveu um agente pedagógico que possua uma base de
conhecimento capaz de fazer com que ele decida qual a melhor estratégia de aprendizagem que
3
deve ser oferecida ao aluno, bem como qual a maneira mais amigável de incentivá-lo, tendo como
parâmetro atitudes comuns tomadas pelos professores reais.
1.1.2 Solução proposta
A fim de implementar a base de conhecimento do agente pedagógico, este projeto utilizou a
ferramenta JCLIPS (MENKEN, 2005) que serviu como ligação entre a ferramenta de
desenvolvimento de sistemas especialistas CLIPS (RILEY, 2005) e a linguagem Java (SUN,
2006b), na qual o Sistema Tutor Inteligente de Neurofisiologia foi implementado.
Para armazenar as interações de cada aluno, bem como as diversas atitudes e feições do
agente, foi utilizado o banco de dados PostgreSQL (POSTGRESQL, 2006) por ser o mesmo
utilizado pelo Sistema Tutor Inteligente em estudo.
1.2 OBJETIVOS
1.2.1 Objetivo geral
A criação de um agente pedagógico inteligente para um estudo de caso na área da
biomedicina, com enfoque em neurofisiologia, e desenvolver o sistema de comunicação e
acoplamento de um STI com a ferramenta JCLIPS.
1.2.2 Objetivos específicos
O trabalho focou-se nos seguintes objetivos:
• Analisar o modelo conceitual do Sistema Tutor Inteligente;
• Analisar conexão entre JCLIPS x PostgreSQL;
• Estabelecer as variáveis do Sistema Tutor Inteligente que o agente fará uso;
• Criar a árvore de decisões do sistema especialista;
• Validar as regras de produção geradas pela árvore de decisões;
• Implementar as regras de produção no JCLIPS;
• Implementar comunicação JCLIPS x PostgreSQL; e
• Testar o agente dentro do contexto do Sistema Tutor Inteligente.
4
1.3 Metodologia
Para o desenvolvimento deste TCC, a seguinte metodologia foi seguida.
Primeiramente foi feita uma análise do modelo conceitual do STI em Neurofisiologia. A
análise baseou-se na modelagem feita pela equipe responsável pela implementação do sistema junto
ao projeto “Sistemas Virtuais de Ensino Baseados na Internet para Suporte à Educação e
Treinamento na Área de Saúde”. A modelagem do portal é apresentada no ANEXO I, e a
modelagem do sistema tutor é apresentada no ANEXO II. Verificou-se então quais as variáveis de
banco de dados do STI o agente pedagógico faria uso. A próxima etapa foi analisar a conexão entre
o JCLIPS e o PostgreSQL, a fim de verificar as formas de implementação desta comunicação.
Foram criadas então as regras de decisão do agente pedagógico, que foram validadas no
Expert Sinta (LIA/UFC, 1996), sendo que a implementação das regras de produção no JCLIPS foi
feita com base nos conceitos do CLIPS e do funcionamento do algoritmo de Rete. A implementação
da comunicação do JCLIPS com o PostgreSQL foi feita considerando os tipos de variáveis a serem
manipuladas. Foi estudada a forma de exibição para o usuário das feições do agente, por se tratar de
uma variável complexa para exibição, uma vez que sua aparição em tempo real requer uma
programação individualizada.
1.4 Estrutura do trabalho
Este trabalho está dividido nos seguintes capítulos: Introdução, Fundamentação Teórica,
Desenvolvimento e Conclusão. O primeiro capítulo apresenta a introdução, os objetivos, a
metodologia e a estrutura do trabalho.
O capítulo seguinte traz uma abordagem geral das teorias vistas neste trabalho. Inicia
apresentando como a informática começou a ser aplicada na educação, sua evolução e problemas
até os dias de hoje. São vistas várias abordagens de uso do computador na informática, onde uma
delas refere-se a utilização de Sistemas Tutores Inteligentes (STI) para ensino. É feita, então, uma
análise das questões a que o STI se propõe a resolver, seu crescimento e desenvolvimento ao longo
do tempo. A explicação então se encaminha para os agentes pedagógicos inteligentes, que é a
abordagem moderna de desenvolvimento de STI. É descrito também o estudo para escolha das
melhores tecnologias para desenvolvimento tanto da inteligência do agente, como da armazenagem
dos dados pertinentes.
5
O terceiro capítulo refere-se ao projeto de desenvolvimento do sistema que foi concebido
neste TCC. É feita também uma descrição de como a comunicação dos módulos do sistema
funciona. Também é mencionada no processo de desenvolvimento, os problemas encontrados, a
implementação da comunicação e da arquitetura do agente, juntamente com as modificações
necessárias do modelo original.
No quarto e último capítulo tem-se as conclusões e recomendações para trabalhos futuros,
que contém as percepções e considerações obtidas com o desenvolvimento do trabalho.
2 FUNDAMENTAÇÃO TEÓRICA
2.1 Informática na educação (IE)
Os recursos atuais de aprendizados disponíveis devido à tecnologia da informação faz com
que o computador acabe mudando a relação do aluno com o professor, sendo uma ferramenta
poderosa dentre as várias disponíveis em um ambiente de ensino. O computador é entendido como
uma ferramenta porque além de trazer todos os recursos de hipermídia inerentes a ele, os fazem
disponíveis virtualmente em qualquer ponto do planeta com acesso à Internet. Segundo Mason
(1998, apud SILVA, 2006), existem poucas dúvidas de que a Internet é a ferramenta educacional
mais poderosa surgida nos últimos tempos.
Deve-se ter claro que as atividades com o computador na escola podem ser feitas de duas
formas distintas (BARROS e D’AMBROSIO, 1998 apud MENESES, 2000): ensino de informática
e ensino pela informática. O ensino de informática caracteriza-se por dar noções de conceitos de
programação e princípios de funcionamento do computador ao aluno. Esta forma contribui muito
pouco para a melhoria da qualidade do ensino no geral, sendo na maioria das vezes usada pelas
escolas visando atrair a atenção dos alunos. Este conhecimento é um conhecimento específico da
ferramenta, e de pouco valor pedagógico. O segundo modelo, de ensino pela informática, é o que se
chama e caracteriza a informática educativa, e usa o computador como ferramenta de ensino. Este
modelo envolve o aluno em diversas atividades que podem ser desenvolvidas pelo computador,
permitindo desenvolver estratégias de aprendizagem que contribuam na assimilação dos conteúdos
de diversos domínios trabalhados em sala de aula. Este segundo modelo é o que se tornou alvo de
fortes estudos pedagógicos para um formato de melhor uso possível do computador como
ferramenta.
2.1.1 Histórico da IE
As tentativas de se utilizar o computador como ferramenta de aprendizagem em ensino
começaram no início dos anos 60 nos Estados Unidos com a instrução programada (VALENTE e
ALMEIDA, 1997). Segundo Valente (1993) o conceito de instrução programada eletrônica
consistia em dividir o material em pequenos segmentos, denominados módulos, que são encadeados
logicamente. Fatos e conceitos do assunto de domínio eram representados em módulos seqüenciais.
No final de cada módulo o aluno respondia uma questão referente ao módulo através do
7
preenchimento de um espaço em branco ou da escolha de uma das alternativas de resposta. Sendo
assim o estudante seria sempre questionado do fato ou conceito que acabou de ler. Se a resposta
fosse correta seria permitido ao aluno então passar ao módulo seguinte. Caso a resposta fosse errada
o programa poderia apresentar reações diferentes, como fornecer a resposta correta, convidar o
aluno a rever módulos anteriores ou, ainda, realizar a leitura e estudo de outros módulos, cujo
objetivo era remediar o processo de ensino.
Esta alternativa eletrônica era denominada CAI (Computer Aided Instruction) e viabilizava a
popularização deste conceito de instrução programada, já que a produção destes materiais
instrucionais no formato impresso é difícil e os materiais que existem não possuem padronização
alguma.
O Brasil tem uma abordagem acadêmica da informática na educação. Aqui este tema surgiu
nas universidades e continuou sendo discutido dentro delas. Sendo assim, as decisões e as propostas
nunca foram totalmente centralizadas no governo, mas eram fruto de propostas feitas pela
comunidade de técnicos e pesquisadores da área e tendo o governo o papel de acompanhar,
viabilizar e implementar essas decisões (VALENTE e ALMEIDA, 1997).
2.1.2 Taxonomia
Inicialmente é necessário definir o que se entende por “programa educacional”. Tem-se a
definição de Viccari e Giraffa (2003) que diz que “todo programa pode ser considerado um
programa educacional, desde que utilize uma metodologia que o contextualize no processo de
ensino-aprendizagem”. Já Lucena (1992, apud TEIXEIRA e BRANDÃO, 2003) diz que um
software educacional “é todo aquele programa que possa ser usado para algum objetivo
educacional, pedagogicamente defensável, por professores e alunos, qualquer que seja a natureza ou
finalidade para o qual tenha sido criado”.
Os CAI são formados basicamente de softwares que têm a aprendizagem focada na
aquisição de habilidades específicas (VICCARI e GIRAFFA, 2003). São softwares que funcionam
como a máquina de ensinar de Skinner, e pregam as idéias do cientista. As teorias de Skinner dizem
que o comportamento e a aprendizagem são conseqüências de estímulos que resultem em uma
recompensa e defendem a idéia de que “toda ação que produza satisfação tenderá a ser repetida e
conseqüentemente aprendida” (SKINNER, 1953 apud MENESES, 2000). Esta é a teoria do
8
condicionamento, ou o behaviorismo. Dentro deste grupo se observam também as seguintes
modalidades (VICCARI e GIRAFFA, 2003):
1. Programas de reforço ou exercício: o aluno pratica e testa conhecimentos de forma
dirigida e procedural;
2. Tutoriais: o conteúdo é definido e organizado pelo professor, seguindo o padrão de
ensino da sala de aula; e
3. Jogos educacionais e as simulações: Utiliza recursos pesados de hardware e software. O
jogo se diferencia da simulação por causa da competição e da coexistência de “vitória e
derrota”. Os jogos também podem ter outras abordagens que não são behavioristas.
Os CAI, então, adquiriram técnicas de IA e originaram os ICAI (Intelligent Computer Aided
Instruction) como tentativa de sobressair aos sistemas sem inteligência, levando em conta as críticas
de que os CAI são sistemas que simplesmente fazem a mesma coisa que o papel, sem ganhos
significativos no nível de ensino-aprendizagem. Os ICAI, então, passam a ter os conteúdos em
módulos mais independentes e tentam se ajustar de acordo com o desempenho do aluno. Eles saem
do behaviorismo, e passam a se basear no cognitivismo (VICCARI e GIRAFFA, 2003).
Essas críticas aos sistemas de ensino CAI e ao behaviorismo de Skinner são presentes em
muitos trabalhos, como o de Rego (1995 apud KOMOSINSKI, 2000), que diz que nos trabalhos de
Skinner “a aprendizagem é confundida com memorização de um conjunto de conteúdos
desarticulados, conseguida através da repetição de exercícios sistemáticos de fixação e cópia e
estimulada por reforços positivos (elogios, recompensas) ou negativos (notas baixas, castigos,
etc.)”. Alguns exemplos de softwares educacionais que seguem estas filosofias não-behavioristas
são citados a seguir (VICCARI e GIRAFFA, 2003):
1. Micromundos: trabalham basicamente com a solução de problemas, dando ferramentas e
recursos para o aluno montar a sua solução;
2. Sistemas de Autoria: são ferramentas de criação que possibilitam ao aluno viabilizar seu
projeto de trabalho, exercendo sua criatividade;
3. Jogos Educacionais: aqui o jogo educacional é abordado de uma maneira mais
complexa, e vai além de ganhar ou perder. A existência de um modelo de simulação,
9
onde o tipo de ação executada pelo aluno irá influenciar nas condições de término e
resultado do jogo, nos traz ao final do jogo um grau de controle atingido pelo aluno; e
4. ILE (Integrated Learning Environments): ambientes de convivência social que utilizam
técnicas de IA. Caracterizam-se por ter mais de um aluno ou tutor trabalhando
simultaneamente.
Os STI (Sistemas Tutores Inteligentes) surgem como uma evolução dos ICAI, que já eram
inteligentes, mas que agora também levam em conta uma modelagem de perfil do aluno. Isso
implica em um certo grau de autonomia aos STI durante sua interação, também de personalização e
adaptação, de acordo com as necessidades do aluno. Para isso, os STI precisam ter acesso a várias
formas de representação de conhecimento e a vários tipos de raciocínio (SELF, 1995). Dessa forma,
os STI têm sido utilizados para qualquer abordagem pedagógica.
2.2 STI
As definições de STI são muitas, sendo que algumas tratam o STI como qualquer sistema de
suporte ao ensino com um grau de inteligência. Segundo Gamboa e Fred (2001) “Os STI são
programas de software que dão suporte às atividades da aprendizagem”. Essa afirmação é reiterada,
com uma ressalva mais destacada de IA, por Freedman (2000), que diz que “STI é um termo amplo
que abrange qualquer programa de computador que contém alguma inteligência e pode ser usado
em aprendizagem”. Sleeman (1982, apud VICCARI e GIRAFFA, 2003) diz que “os STI são
programas de computador que utilizam técnicas de IA para representar o conhecimento e levar a
termo uma interação com o aluno”.
Há também a definição de Fowler (1991, apud ALVES, 2002) que diz que os STI são
programas de computador com propósitos educacionais e que incorporam técnicas de IA,
geralmente utilizando-se da tecnologia dos sistemas especialistas. A definição de Loinaz (2001) diz
que STI são aqueles sistemas desenvolvidos num contexto de pedagogia cujas capacidades fazem
uso de IA. Loinaz (2001) também diz que para podermos abordar com um certo grau de adequação
o desenvolvimento de um STI, é necessário contar com técnicas de ciência da computação,
exposições que facilitem a motivação de um aluno em frente ao computador, e parâmetros
pedagógicos ou de ciências da educação que reiterem e sustentem o processo de instrução e
aprendizagem mediante as novas tecnologias.
10
Tem-se clara a necessidade do STI de suporte ao aluno, ou seja, a existência de um meio de
guiar o aluno pelo conteúdo da melhor forma possível, levando em conta suas dúvidas, dificuldades
e facilidades. Segundo Viccari e Giraffa (2003), isso faz com que o objetivo fundamental do STI
seja “proporcionar um ambiente adaptado ao aluno, tanto no conteúdo como na forma, superando
dessa maneira alguns dos problemas mais cruciais do software educativo”. Loinaz (2001) mostra
um resumo das principais características dos STI que embasam este objetivo: o conhecimento do
domínio anotado está claramente articulado; possuem conhecimento do aluno que permitam dirigir
e adaptar sua educação; a seqüência de ensinamento não está predeterminada pelo projetista;
realizam processos de diagnóstico mais detalhados e adaptados aos estudantes; e melhoria da
comunicação aluno-tutor.
Os STI se baseiam em uma grande quantidade de conteúdo informacional, elaborado por
pesquisadores e especialistas em um domínio, a partir do qual o sistema interage com o aluno
através de um tutor com capacidade de comunicação e orientação. Pode-se dizer então que os
sistemas tutores inteligentes são uma composição de diversas disciplinas como psicologia, educação
e treinamento através de uma ciência cognitiva e inteligência artificial (EBERSPÄCHER e
KAESTNER, 1998). O objetivo principal destes sistemas é a modelagem e representação do
conhecimento especialista humano para auxiliar o estudante através de um processo interativo
(HALL, 1990 apud COSTA 1999).
É responsabilidade dos STI compor interações educacionais dinamicamente (CHAIBEN,
1999), além de adaptar o conteúdo a inteligência que mais está ativa no aluno. Para Jonassen (1993
apud ALVES, 2002), um STI deve passar em três testes antes de ser considerado “inteligente”: o
conteúdo do tema ou especialidade deve ser codificado de modo que o sistema possa acessar as
informações, fazer inferências ou resolver problemas; o sistema deve ser capaz de avaliar a
aquisição deste conhecimento pelo estudante; e as estratégias tutoriais devem ser projetadas para
reduzir a discrepância entre o conhecimento do especialista e o conhecimento do estudante.
Segundo Silva (2006), os STI também são usados em conjunto com as aulas tradicionais
sem computador e com um tutor humano, através da Internet, para “aumentar o nível de interação
do aluno à medida que implementam estratégias para supervisionar as suas ações e propor
alternativas dinamicamente, de acordo com os princípios e a proposta pedagógica do conteúdo em
questão”. Sendo assim observa-se também uma possível abordagem de uso do STI onde ele não se
11
comporta sobrepondo um tutor humano, mas visa apenas agregar valor e qualidade às interações em
um ambiente virtual de aprendizagem.
2.2.1 Histórico dos STI
Nos anos 50 apareceram os primeiros sistemas de ensino, os chamados programas lineares
(LOINAZ, 2001). Estes softwares iniciais eram caracterizados por mostrar seu conteúdo de forma
linear, sendo que nenhuma mudança do educador era permitida no software depois que ele tivesse
vindo do programador.
Os sucessores destes softwares lineares foram os programas ramificados (CROWDED, 1959
apud LOINAZ 2001). Estes eram diferentes pela habilidade de se modificar de acordo com as
respostas do aluno. Nos anos 70 surgiram sistemas chamados sistemas generativos (também
chamados sistemas adaptativos), que seguiam a idéia de que os problemas que o aluno enfrenta
deveriam ter graus de dificuldade adequáveis ao conhecimento do aluno.
Na década de 70 surgiram os STI. Carbonell (1970 apud GIRAFFA e GOULART, 2001)
apresentou uma nova proposta sobre como tratar a questão da “aprendizagem-computadorizada”.
Ele propôs, com um sistema denominado SCHOLAR, com uma nova maneira de conceber sistemas
educacionais, levando em consideração a forma como o professor estrutura e desenvolve o conteúdo
em sala de aula. Ou seja, considerando a dinamicidade que existe na relação aluno-professor. Ele se
baseou no fato de que numa situação de sala de aula o professor observa os alunos e faz uma
verificação constante do que está acontecendo durante o andamento das atividades na sala de aula,
sendo que isto deveria ser possível de ser modelado em um software educacional. (GIRAFFA e
GOULART, 2001).
A partir dos anos 80 o estudo passou a focar o aspecto pedagógico e os especialistas em
educação foram incorporados as equipes de estudo (VICCARI e GIRAFFA, 2003). Os últimos 10
anos têm funcionado como adaptação aos novos recursos de informática, tais como multimídia,
hipermídia e o surgimento de novos paradigmas de desenvolvimento de software, como a
programação orientada a objetos, e o uso de agentes.
Estes estudos geraram o crescimento de sistemas de diversos pontos de vista didáticos e
pedagógicos, e de vários métodos de desenvolvimentos de STI que vem em contrapartida ao
método clássico de desenvolvimento que era utilizado anteriormente. Sendo assim dois paradigmas
12
de desenvolvimento de STI têm se mostrado mais presentes, o clássico e o baseado em agentes
(VICCARI e GIRAFFA, 2003).
2.2.2 Arquitetura clássica dos STI
As arquiteturas de STI geralmente apresentam organizações básicas observáveis na maioria
dos casos, mesmo que cada sistema possua suas peculiaridades (VICCARI e GIRAFFA, 2003).
Este modelo, o chamado clássico, foi formado ao longo dos anos e de evolução dos STI e foi
iniciado no SCHOLAR, sistema anteriormente citado e proposto por Carbonel (1970 apud
GIRAFFA e GOULART, 2001), no qual o conteúdo era representado de uma forma onde um
diálogo era mantido com o aluno, através do formato textual, utilizando um subconjunto da língua
natural em que o sistema foi desenvolvido. O sistema se baseava nos avanços da área de IA, na
época (década de 70). Esse foi o primeiro STI e tinha como principal objetivo realizar a tarefa de
ensino de um dado conteúdo (domínio) na forma mais adaptada às necessidades individuais do
aluno. Segundo Giraffa e Goulart (2001), estes sistemas se baseiam em uma arquitetura
(representada na Figura 1) composta basicamente por:
• Módulo aluno: neste módulo estão armazenadas/modeladas as características individuais
do aluno (conhecimento individual sobre o domínio, por exemplo);
• Módulo tutor: possui estratégias e táticas e as seleciona em função das características do
aluno (representadas no módulo aluno);
• Módulo domínio: detêm o conhecimento sobre a matéria no formato de regras de
produção, estereótipos, etc.; e
• Interface: faz o intermédio da interação entre o tutor e o aluno.
Esta arquitetura é denominada de clássica e também conhecida como “funcional tripartida”
ou tradicional de STI. O termo “tripartida” se refere às funções associadas aos módulos tutor, do
aluno e domínio. Esta proposta trouxe grandes avanços à modelagem de ambientes educacionais,
pois separou o domínio da sua forma de manipulação (no sentido de utilização), permitindo, assim,
que estratégias de ensino fossem associadas em função das informações oriundas da modelagem do
aluno (GIRAFFA e GOULART, 2001).
13
Figura 1. Arquitetura clássica de um STI
Fonte: Giraffa e Goulart (2001).
A Figura 2 mostra como Self (1999 apud GIRAFFA e GOULART, 2001) associou à
arquitetura clássica um modelo de interação. Segundo Giraffa e Goulart (2001) neste modelo o
módulo de domínio não é mais uma forma de tornar as informações inter-relacionadas, mas sim um
modelo dos aspectos do conhecimento sobre o domínio que o aluno pode acessar durante as
interações com o STI (Modelo da situação).
Pode-se dizer então, de maneira mais detalhada, que o modelo de domínio, ou situação, é
constituído pelo material instrucional (lições, animações, filmes, exercícios, exemplos, desafios,
dicas, etc.). Ele contém o conhecimento sobre o domínio que se deseja trabalhar com o estudante.
Vários modelos de representação de conhecimento podem ser usados para armazenar o conteúdo,
como: regras de produção, páginas HTML (Hyper Text Markup Language), entre outras, e a escolha
deve recair sobre aquele método que melhor e mais facilmente atenda aos requisitos de
representação e manipulação do conteúdo (GIRAFFA e GOULART, 2001).
O módulo do estudante passa então a não relacionar somente as informações sobre a análise
das interações do aluno com o domínio, mas a buscar uma contextualização maior destas interações
em função das ações do aluno, o contexto em que elas ocorrem e a estrutura cognitiva do aluno
naquele momento (Modelo de Interação). O módulo tutor deixou de ser o responsável pela seleção
do conteúdo e estratégias para se tornar, de uma forma mais ampla, aquele que conduz o aluno de
acordo com objetivos e desafios educacionais que o ambiente proporciona ao aluno (Modelo de
permissões) (GIRAFFA e GOULART, 2001).
14
Figura 2. Arquitetura ampliada do STI
Fonte: Self (1999 apud GIRAFFA e GOULART, 2001).
Já o modelo do aluno, ou de interação, representa o conhecimento e as habilidades
cognitivas do aluno em um dado momento. Segundo Viccari (1990 apud VICCARI e GIRAFFA,
2003), o modelo é constituído por dados estáticos e dinâmicos que serão de fundamental
importância para o tutor poder comprovar hipóteses a respeito do conhecimento e do
comportamento do aluno. Para construir este modelo muitas técnicas são utilizadas, tais como:
reconhecimento de padrões aplicados às respostas fornecidas, comparação dos pontos em comum
da conduta do aluno com a de um especialista e a captura de esquecimentos comuns, preferências,
desejos, crenças e intenções do aluno. O sistema então infere a partir deste modelo e do
conhecimento na base de domínio, a melhor estratégia de ação para ser usada para cada aluno
(VICCARI e GIRAFFA, 2003).
O módulo tutor decide quando uma intervenção é desejável, se o aluno deve ser
interrompido em sua atividade ou não e o que deve ser apresentado em função das informações
avaliadas em um dado momento. A ordem e a maneira com que cada assunto é trabalhado pode
produzir diferentes resultados na aprendizagem (GIRAFFA e GOULART, 2001). Segundo Wenger
(1987 apud GIRAFFA e GOULART, 2001), na abordagem clássica o papel do módulo tutor é
tomar as decisões pedagógicas em função das interações com o aluno. Estas decisões derivam de
regras ou estruturas de conhecimento que representam o conhecimento do tutor a respeito do
domínio, estando representadas de forma definida no sistema (Módulo Tutor) (GIRAFFA e
GOULART, 2001).
Nos STI clássicos o controle varia conforme algum critério de otimização, e costuma ser
uma decisão de projeto, ou seja, não existe mudança na forma com que é controlada a interação.
15
Alguns sistemas podem monitorar as atividades dos alunos de perto, adaptando suas ações as
respostas dos alunos, mas nunca cedendo o controle da interação. Observa-se também que os STI
clássicos, de uma forma geral, se caracterizam por utilizar uma única estratégia para o ensino do
aluno. Ou seja, estes sistemas possuem pouca versatilidade em seu comportamento pedagógico, sem
proporcionar uma adaptação dinâmica (em nível de estratégias) para as características individuais
de aprendizagem de cada aluno (GIRAFFA e GOULART, 2001).
2.3 Agentes inteligentes
A idéia de agentes não é nova na Ciência da Computação. Segundo Kay (1984 apud
COSTA, 1999), ela foi originada na década de 50 por John McCarthy e Oliver Selfridge. Ambos
idealizaram um sistema que tentaria atingir um objetivo dado através da execução de uma seqüência
de ações. Esse software seria um robô virtual, ou soft robot, vivendo e realizando seus negócios
dentro de um universo computacional. A partir da década de 70, Hewitt (1977 apud COSTA, 1999)
propôs um sistema auto-suficiente, interativo e com execução concorrente, o qual ele denominava
“ator”.
A dificuldade em definir o que seriam agentes inteligentes está, principalmente, na definição
do que é “inteligência”. Em geral, o termo “agente” aparece na literatura computacional
determinando diversos tipos de programas que não precisam, necessariamente, ser "inteligente" ou
apresentar algum comportamento característico, mas que são atrelados a algum contexto. De
qualquer forma, caracterizar o que é "inteligência", ou estabelecer o que seria um comportamento
inteligente é uma tarefa difícil (COSTA, 1999).
Segundo Spector (1997) um agente pode ser “qualquer sistema autônomo que percebe e age
para alcançar um estreito conjunto de metas dentro de um específico ambiente virtual ou real”.
Segundo Hendler (1996 apud COSTA, 1999), pode-se afirmar que os pesquisadores em agentes
inteligentes procuram, de forma geral, desenvolver programas sofisticados que podem ser úteis em
ambientes de importância para os humanos. Estes ambientes podem variar desde locais físicos de
difícil acesso ou perigosos para os humanos, até domínios virtuais, como as redes de computadores.
Russell e Norvig (2004) dizem que “um agente é tudo o que pode ser considerado capaz de
perceber seu ambiente por meio de sensores e de agir sobre esse ambiente por intermédio de
atuadores”. Assim como um agente humano, que tem olhos, ouvidos, entre outros órgãos sensoriais
para captar o que acontece ao seu redor, um agente robô, por exemplo, teria sensores de movimento
16
ou infra-vermelho para capturar o que acontece. No agente robô também teríamos motores que
funcionariam como atuadores, no lugar dos braços, mãos, bocas e pernas do agente humano. A
Figura 3 mostra como essa interação ocorre.
Tendo-se um agente de software, por exemplo, capturariam-se as seqüências de teclas
digitadas, conteúdo de arquivos e pacote de redes como entradas sensoriais e, no lugar de braços ou
motores, os atuadores deste agente seriam mensagens exibidas na tela, arquivos gravados e arquivos
enviados pela rede (RUSSELL e NORVIG, 2004).
Figura 3. Agentes interagem com ambientes por meio de sensores e atuadores
Fonte: Russel e Norvig (2004).
2.3.1 Características dos agentes inteligentes
Como visto na Figura 3, Russel e Norvig (2004) usam o termo “percepção” para fazer
referência às entradas perceptivas do agente em qualquer momento dado. Os autores explicam que
os agentes mantêm um histórico de tudo que foi percebido e, a partir disso, tomam uma decisão.
Isso faz com que “toda ação de um agente seja baseada na seqüência inteira de percepções baseadas
até o momento” (RUSSEL e NORVIG, 2004).
Estes autores também afirmam que os agentes têm várias características especiais, que os
definem como inteligentes, tais como racionalidade, onisciência, aprendizado e autonomia. Um
agente racional é aquele que faz tudo certo, ou seja, toda ação executada por ele deve ser a certa, ou
a que fará com que ele tenha o maior sucesso. Deve-se então ter um método para se medir o
sucesso, ou uma medida de desempenho, que devem ser criadas de acordo com o resultado
realmente desejado no ambiente. Então, segundo Russel e Norvig (2004), “um agente racional deve
17
selecionar uma ação que se espera vir a maximizar sua medida de desempenho, dada a evidência
fornecida pela seqüência de percepções e por qualquer conhecimento interno do agente”.
Russel e Norvig (2004) também explicam a onisciência, um conceito que parte da
racionalidade. Um agente onisciente deve ser capaz de não simplesmente tomar ações baseadas nas
suas percepções, que é o que seria a racionalidade, mas deve saber o resultado real de suas ações,
realizando a chamada “coleta de informações”. A coleta de informações ajuda o agente a maximizar
seu desempenho nas suas tarefas, pois compreende a realização de ações simplesmente para
modificar a sua seqüência de percepções. Como exemplo os autores sugerem um agente que tem
como meta “atravessar a rua”. Este agente deve saber que deve “olhar para os lados” antes de
atravessar a rua, para assim incluir em sua seqüência de percepções se existe algum caminhão vindo
ou não em sua direção.
Definições paralelas de agentes trazem uma noção de que um agente é uma entidade “que
parece carregar crenças, desejos, etc.” (SEEL, 1989 apud WOOLDRIDGE e JENNINGS, 1995). A
partir desta afirmação, Wooldridge e Jennings (1995) explicam o agente como um sistema que tem
um processo de inteligência baseado em suas intenções e, sendo assim, abordam também as
seguintes definições de características para verificar se uma entidade é um agente inteligente ou
não:
• Autonomia: agentes que operam sem a intervenção de humanos ou outros, e que tem
algum tipo de controle sobre suas ações e estados internos (CASTELFRANCHI, 1995
apud WOOLDRIDGE e JENNINGS, 1995). Nwana (1996) diz que os agentes
autônomos possuem “estados e metas internos, agindo de maneira a atingir estas metas
em favor de seus usuários”. Nwana (1996) dá como elemento chave da autonomia de um
agente a pró-atividade, que é a sua habilidade de tomar iniciativas, e Foner (1993) fala
que a autonomia tem como requisito básico aspectos de ação periódica, execução
espontânea, e iniciativa, e que assim o agente deve ser capaz de tomar ações preemptivas
e independentes;
• Habilidade social: agentes interagem com outros agentes (e possivelmente humanos)
através de algum tipo de linguagem de comunicação de agente cooperando e trabalhando
em conjunto (GENESERETHAND e KETCHPEL, 1994 apud WOOLDRIDGE e
JENNINGS, 1995);
18
• Reatividade: agentes percebem seu ambiente e respondem em tempo hábil as mudanças
que ocorrem nele;
• Pro-atividade: agentes não simplesmente respondem as alterações nos seus ambientes,
mas são capazes de exibir um comportamento dirigido a atingir seus objetivos através da
tomada de iniciativas;
• Mobilidade: é a habilidade do agente de se mover em uma rede eletrônica entre
computadores (WHITE, 1994 apud WOOLDRIDGE e JENNINGS, 1995). Esta
capacidade é intimamente ligada a agentes que auxiliam seus usuários na busca de
informações;
• Veracidade: assume-se que um agente não vai conscientemente informar dados falsos
(GALLIERS, 1988b apud WOOLDRIDGE e JENNINGS, 1995);
• Benevolência: trata do fato que agentes não tem objetivos conflitantes e, portanto, todo
agente fará o que lhe é pedido (ROSENSCHEIN e GENESERETH, 1985 apud
WOOLDRIDGE e JENNINGS, 1995); e
• Racionalidade: agentes sempre atuam de forma a atingir seus objetivos, e caso atuaram a
ponto de prevenir que seus objetivos sejam realizados é porque seus conhecimentos não
lhe deram o devido suporte a tomara de decisão (GALLIERS, 1988b apud
WOOLDRIDGE e JENNINGS, 1995).
O conceito “agentes aprendendo”, relacionado com a característica “autonomia”, é
perfeitamente subentendido nessa classificação de Wooldridge e Jennings (1995). Uma real
autonomia só pode estar presente quando um agente possui a habilidade de avaliar as variações de
seu ambiente externo e escolher qual a ação mais correta. Entretanto, mesmo quando um agente não
reconhece nenhuma ação a ser executada, é esperado que ele procure encontrar uma saída. A
questão não é acertar sempre, mas aprender continuamente por experiência, seja através de sucessos
ou de fracassos (COSTA, 1999).
Foner (1993) também fala da característica do “antropomorfismo”. Essa característica
denotaria o fato de um agente de software se assemelhar graficamente a um ser humano, tendo
feições e silhuetas humanas. Esta característica, apesar de não tão importante quanto outras como,
por exemplo, autonomia e reatividade, é marcante em softwares com agentes de interface.
19
Segundo Russel e Norvig (2004), o ambiente em que o agente é inserido é, essencialmente,
o conjunto dos “problemas” para quais o agente é a “solução” e influenciam diretamente no projeto
do agente. Estes ambientes devem ser investigados e especificados e podem ser agrupados em
descrições chamadas PEAS (Performance, Environment, Actuators, Sensors), como vistos na
Tabela 1. As especificações de um ambiente dizem respeito aos tipos de dados lá encontrados, suas
variações e a existência de outros agentes (RUSSEL e NORVIG, 2004).
Tabela 1. Exemplos de tipos de agentes e suas descrições de PEAS
Tipo de Agente Medida de Desempenho
Ambiente Atuadores Sensores
Sistema de diagnóstico médico
Paciente saudável, minimizar custos, processos judiciais
Paciente, hospital, equipe
Exibir perguntas, testes, diagnósticos, tratamentos, indicações
Entrada pelo teclado para sintomas, descobertas e respostas do paciente
Sistema de análise de imagens de satélite
Definição correta da categoria da imagem
Link de transmissão de satélite em órbita
Exibir a categorização da cena
Vetor de pixels e cores
Instrutor de inglês interativo
Maximizar nota do aluno em teste
Conjunto de alunos, testes de agência
Exibir exercícios, sugestões, correções
Entrada pelo teclado
Fonte: Adaptado de Russel e Norvig (2004).
Os autores Bigus e Bigus (2001) falam da possibilidade de controle do ambiente, onde o
projetista do agente poderia inclusive alterar o ambiente onde o agente estará situado. No contexto
de agentes inteligentes, um evento é tudo que vem a mudar o ambiente ou qualquer acontecimento
do qual o agente deva estar ciente. Para um agente de software ficar constantemente procurando
alterações do ambiente pode ser desgastante e esgotar recursos computacionais, como
processamento ou memória principal, necessários a outras atividades e, portanto, ter sinais partindo
do ambiente (ou outro agente, por exemplo) avisando o agente (que poderia estar processando
outras informações ou inativo) a cada evento ou ocorrência importantes é uma possibilidade muito
saudável.
Esta idéia de Bigus e Bigus (2001) vai contra o conceito de pro-atividade, e estabelece um
outro paradigma de comportamento, chamado “evento-condição-ação”. A partir da ocorrência do
evento, o agente passaria a etapa de reconhecer e avaliar o evento para então determinar a condição
20
ou estado no qual o ambiente se encontra. Assim que os dados do ambiente são levantados, o agente
reage de acordo com o seu conhecimento e inteligência e executa uma ação a fim de chegar ao
objetivo a qual ele foi projetado.
2.3.2 Arquiteturas de agentes
Russel e Norvig (2004) consideram a arquitetura de um agente algo que torna as percepções
dos sensores disponíveis para o programa agente, executa o programa e alimenta as opções de ação
do programa para os atuadores à medida que eles são gerados. O próprio agente, então, seria a união
da arquitetura com o programa de agente. Se, por exemplo, um programa de agente estiver sendo
executado em algum dispositivo de computação com sensores e atuadores físicos, chama-se esse
conjunto de “arquitetura”.
Tipicamente a arquitetura de software em geral descreve a configuração de alto-nível dos
componentes constituintes de um sistema e as conexões que coordenam as atividades destes
componentes (ABOWD et al., 1996). A arquitetura de software representa decisões de projeto mais
difíceis de serem alteradas e que têm mais impacto sobre a qualidade do software e é, em geral, feita
depois da coleta dos requerimentos e antes de um projeto mais detalhado. A escolha da arquitetura,
então, deve se adequar às necessidades básicas do agente.
Wooldridge e Jennings (1995) se baseiam na definição de Mães (1991 apud
WOOLDRIDGE e JENNINGS, 1995) sobre arquitetura de agentes para defini-las:
Uma arquitetura é uma metodologia particular para a construção de um agente. A arquitetura especifica como um agente pode ser decomposto na construção de um conjunto de módulos e como esses módulos devem se interagir. O conjunto total dos módulos e suas interações deve dar a resposta de como os dados sensoriais e os estados internos do agente determinam suas ações e seus futuros estados internos. Uma arquitetura abrange técnicas e algoritmos que suportam esta tecnologia.
Seguindo esta definição, Wooldridge e Jennings (1995) dividem então as arquiteturas em
três áreas:
1. Arquiteturas deliberativas: é o que o autor chama de “abordagem clássica” de construção
de agentes, no qual ele é visto como um sistema baseado em conhecimento mais
particular, ou parte de um. Aqui os agentes possuem modelos simbólicos de seus
ambientes;
21
2. Arquiteturas reativas: é uma arquitetura que não inclui nenhum tipo de modelo
simbólico, ou qualquer raciocínio simbólico complexo. O comportamento inteligente
surgiria do resultado de uma interação do agente com o seu ambiente; e
3. Arquiteturas híbridas: aqui o agente é dividido em camadas que incluem ambos, tendo
comportamentos dos agentes deliberativos quanto dos agentes reativos.
Russel e Norvig (2004) baseiam a sua classificação das arquiteturas nas suas definições de
características de agentes (racionalidade, onisciência, aprendizado e autonomia) e as dividem em 4
tipos básicos: agentes reativos simples, agentes reativos baseados em modelo, agentes baseados em
objetivos, e os agentes baseados em utilidade.
Inicialmente, como primeira arquitetura descrita por Ruseel e Norvig (2004), os agentes
reativos simples selecionam ações baseando-se na percepção atual, ignorando o histórico de
percepções. O agente realiza algum processamento para identificar o que os seus sensores acabaram
de captar e identificar aquilo como uma condição. Ele então tenta achar alguma conexão entre uma
condição e uma ação a ser tomada. Estas conexões podem ser chamadas de várias formas, tais
como: regras “condição-ação”, regras “situação-ação”, regras de “produção” ou regras “se-então”
(RUSSEL e NORVIG, 2004). Na Figura 4 este processamento está melhor descrito através de um
pseudo-código.
função AGENTE_REATIVO_SIMPLES(percepção ) retorna uma ação variáveis_estáticas regras : um conjunto de regras condição-ação estado <- INTERPRETAR_ENTRADA( percepção ) regra <- REGRA_CORRESPONDENTE(estado , regras ) ação <- AÇÃO_DA_REGRA[ regra ] retornar ação fim_função
Figura 4. Pseudocódigo de um agente reativo simples
Fonte: Adaptado de Russel e Norvig (2004).
Para a construção de um agente deste tipo deve-se então implementar um interpretador de
entradas e criar um conjunto de regras. O interpretador nos retorna o estado do ambiente, e as regras
definem que ação deve ser tomada levando em conta este estado. Os agentes reativos simples têm
como forte propriedade a sua simplicidade, o que implica em uma inteligência muito limitada. A
Figura 5 mostra a estrutura desse agente e mostra como as regras funcionam exatamente para trazer
esta conexão entre percepção e ação (RUSSEL e NORVIG, 2004).
22
Para situações onde apenas a percepção atual não é o suficiente, deve-se então adicionar
mais complexidade ao agente. O agente pode, por exemplo, tentar controlar a parte do mundo que
ele não pode ver agora, através da manutenção de um estado interno que mantenha um histórico de
percepções. Para isto o agente precisa de um conhecimento extra, contendo algumas informações de
como o mundo funciona, ou um “modelo” do mundo. E é isso que os agentes reativos baseados em
modelos, descritos por Russel e Norvig (2004), fazem e que pode ser visto no diagrama da Figura 6
e Figura 7.
Figura 5. Diagrama esquemático de um agente reativo simples
Fonte: Russel e Norvig (2004).
função AGENTE_REATIVO_COM_ESTADOS(percepção ) retorna uma ação variáveis_estáticas estado : uma descrição do estado atual do mundo regras : um conjunto de regras condição-ação ação : a ação mais recente, inicialmente nenhuma estado <- ATUALIZAR_ESTADO( estado , ação , percepção ) regra <- REGRA_CORRESPONDENTE(estado , regras ) ação <- AÇÃO_DA_REGRA[ regra ] retornar ação fim_função
Figura 6. Pseudo-código de um agente reativo baseado em modelo
Fonte: Adaptado de Russel e Norvig (2004).
Como visto na Figura 6, um agente reativo com estados, ou baseado em modelo, passa então
a ter um controle do mundo usando um modelo interno. Logo após ele determinar o estado atual do
mundo, ele escolhe uma ação da mesma maneira que o agente reativo simples, conforme visto na
Figura 7 (RUSSEL e NORVIG, 2004).
23
Figura 7. Um agente reativo baseado em modelo
Fonte: Russel e Norvig (2004).
Acontece que conhecer o ambiente nem sempre é o suficiente para atribuir poder de decisão
ao agente. Pode-se ter como exemplo o agente motorista de táxi, descrito no PEAS da Tabela 1.
Caso esse agente esteja com seu carro parado em um entroncamento de estradas percebido por seus
sensores, o táxi pode virar a qualquer um dos lados ou seguir em frente. Como saber aonde seguir?
Uma decisão correta dependeria de onde se quer chegar, e isso o agente motorista de táxi não sabe.
Deve-se então, como descrito na Figura 8, adicionar alguma informação sobre objetivos que
descrevam metas necessárias ou desejáveis, como, por exemplo, para o motorista de táxi o destino
do passageiro (RUSSEL e NORVIG, 2004).
Os agentes baseados em objetivos têm alguns problemas, como a realização de muitas ações
para atingir um objetivo, onde entrariam técnicas de busca e planejamento para esse possível
impasse, porém eles possuem um nível maior de flexibilidade quando possibilitam a alteração de
um objetivo para modificar o comportamento do agente. Um agente reativo simples, por exemplo,
teria de ter todas as suas regras alteradas para a mudança de seu comportamento (RUSSEL e
NORVIG, 2004).
24
Figura 8. Um agente baseado em modelos e orientado para objetivos
Fonte: Russel e Norvig (2004).
A quarta e última arquitetura de agente descrita por Russel e Norvig (2004) é a de agentes
baseados na utilidade. O funcionamento deste tipo de agente é visto no diagrama da Figura 9.
Figura 9. Um agente baseado em modelo e orientado para utilidade
Fonte: Adaptado de Russel e Norvig (2004).
A “função de utilidade” examina um ou mais estados e determina graus de utilidade para
cada um. Sendo assim, um agente que trabalha desta forma usa um modelo do mundo, juntamente
25
com uma função de utilidade que mede suas preferências entre estados do mundo. Em seguida, ele
escolhe a ação que leva à melhor utilidade esperada, na qual a utilidade esperada é calculada pela
média entre todos os estados resultantes possíveis, ponderados pela probabilidade do resultado.
2.3.3 Taxonomia de agentes
Pode-se afirmar que é a função do agente que determinará a escolha das suas características
e arquiteturas e é o que, em geral, define sua tipologia. Franklin e Graesser (1996) seguem essa
idéia e defendem uma taxonomia que envolva as definições do agente, como visto na Figura 10. Os
autores, porém, subdividem a classificação baseando-se no jeito qual as espécies do mundo natural
são classificadas, criando um diagrama que se assemelha a uma árvore. As nomenclaturas se
subdividem da seguinte forma (FRANKLIN e GRAESSER, 1996): reino (agentes biológicos,
robóticos e computacionais), filo (agentes de software e de vida artificial), e classe (agentes de
tarefas específicas, de entretenimento e os vírus de computador).
Já Caglayan e Harrison (1997 apud COSTA 1999) propõem uma taxonomia mais objetiva, e
que leva em conta os conceitos de ambiente, tarefa e arquitetura dividindo assim os agentes em três
categorias. A primeira, chamada Desktop, abrange os agentes de interface que oferecem serviços de
assistência aos seus usuários. Em segundo tem-se os agentes chamados Internet, que oferecem
serviços de busca, filtragem e recuperação de informações. Os agentes móveis e de notificação
também estão inclusos nesta categoria. Por último ele define a categoria de agentes do tipo Intranet
como sendo aqueles que existem dentro das organizações, automatizando processos do fluxo de
trabalho. Aqui também se classificam os agentes que manipulam bancos de dados e que alocam
recursos em uma arquitetura cliente/servidor.
Figura 10. Taxonomia de agentes baseada no mundo natural
Fonte: Adaptado de Franklin e Graesser (1996)
26
Em uma abordagem mais ampla, Nwana (1996) se baseia em mais características e defende
uma tipologia dividida em várias dimensões para a classificação de agentes de software. Nwana
(1996) estudou os agentes existentes e tentou colocá-los dentro de diferentes classes de agentes,
chegando as seguintes dimensões:
1. Estático ou móvel: agentes podem ser classificados por sua mobilidade, ou sua
habilidade de se mover em uma rede de computadores. Lange (1998) considera essa
habilidade como importante em sistemas distribuídos e mostra alguns benefícios, tais
como: redução de carga na rede, superação da latência da rede, adaptação dinâmica,
tolerância à falhas, etc.
2. Deliberativo ou reativo: agentes deliberativos derivam de um paradigma de raciocínio
baseado em modelos simbólicos internos enquanto os reativos agem usando um
comportamento do tipo estímulo/resposta respondendo ao estado presente do ambiente
onde se encontram.
3. Quanto a existência de autonomia, aprendizado e cooperação: Nwana (1996) diz que
essas três características são as mais básicas de um agente, e que uma classificação
adequada deveria incluir ou não a existência dessas características no agente em questão.
Essas três características geram quatro das sete classificações finais dadas por Nwana
(1996), são elas: agentes inteligentes, agentes de aprendizagem colaborativa, agentes
colaborativos e agentes de interface. Esta derivação pode ser visto na Figura 11.
4. Quanto a tarefa: uma das dimensões categoriza o papel funcional do agente. Agentes
podem ser, por exemplo, de busca ou de recuperação de informação. Agentes deste tipo
em geral exploram ferramentas de busca e ajudam a organizar informações em uma rede
ampla, como a Internet. Refere-se então a esta classe de agentes citando o seu papel
como buscadores de informação, no caso, agentes de informação. Então, estes agentes de
informação podem também ser móveis, ou deliberativos. Além dos agentes de
informação temos também os agentes de relatório, agentes de apresentação, agentes de
análise, agentes de teste, agentes de interface, etc.
5. Características híbridas: se o agente inclui características híbridas de uma ou mais
filosofias de agente.
27
Figura 11. Uma parte da tipologia de agentes multidimensional
Fonte: Adaptado de Nwana (1996).
Na Figura 12 é possível ver como os quatro tipos de classificação, obtidos quanto a
existência de autonomia, aprendizado e cooperação no agente, se juntam as outras três
classificações obtidas das outras características gerando a tipologia de Nwana (1996), que é
composta por: agentes colaborativos, agentes de interface, agentes móveis, agentes de
informação/Internet, agentes reativos, agentes híbridos e agentes inteligentes.
Figura 12. Classificação multidimensional completa
Fonte: Adaptado de Nwana (1996).
2.3.4 Agentes de interface
Agentes de interface dão ênfase a autonomia e ao aprendizado (NWANA, 1996). Como
metáfora básica, o agente de interface é visto como um assistente pessoal que colabora com o
usuário num mesmo ambiente de trabalho. O agente de interface utiliza o poder da colaboração,
porém não com outros agentes, mas com o usuário em si. Segundo Minsky (1994 apud COSTA
1999), a idéia de utilizar agentes inteligentes como assistentes pessoais torna-se mais clara a medida
que a tecnologia de agentes evolui.
28
A Figura 13 demonstra o funcionamento de agentes de interface segundo Maes (1994 apud
NWANA, 1996). A figura demonstra como o agente faz perguntas a outros agentes, como em um
trabalho colaborativo, porém a interação do agente poderia ser dada diretamente com, por exemplo,
um banco de dados, ou um web service. Um web service é um sistema baseado em web que usa
protocolos de transporte baseados em XML (eXtensible Markup Language) para a troca de dados
com clientes requisitores (SUN, 2006a). Já XML é uma linguagem em formato texto que foi
originalmente desenvolvida para a publicação de material eletrônico em larga escala (W3C, 2006).
Por essência, agentes de interface têm a função de prover suporte e assistência, tipicamente
para um usuário em fase de aprendizado de algum programa ou assunto. Um agente de interface que
ajudasse na utilização de um programa, por exemplo, observaria e monitoraria as ações tomadas
pelo usuário na interface (como se fosse um agente humano “olhando sobre o ombro do usuário”),
ensinaria novos “atalhos” e sugeriria novas formas de realizar tarefas (NWANA, 1996). Além disso,
o agente se comportaria como um assistente pessoal autônomo, que coopera com o usuário na
realização de tarefas do software.
Figura 13. Como os agentes de interface funcionam
Fonte: Adaptado de Maes (1994 apud NWANA, 1996).
Quanto ao aprendizado dos agentes de interface, Maes (1994 apud NWANA, 1996) diz que
esta é uma forma do agente auxiliar melhor os seus usuários. O autor mostra quatro maneiras, todas
demonstradas na Figura 13, com as quais o agente aprende. São elas:
• Observando e imitando o usuário (aprendendo a partir do usuário).
29
• Recebendo do usuário feedback positivo e negativo (aprendendo a partir do usuário).
• Recebendo instruções explícitas do usuário (aprendendo a partir do usuário).
• Solicitando orientação para outros agentes (aprendendo a partir de parceiros).
A cooperação com outros agentes, se existente, é tipicamente limitada a realização de
perguntas e interpretação de respostas. A realização de perguntas é, basicamente, num contexto de
“aconselhamento” e não adentrando em negociações complexas como no caso de agentes
colaborativos. Em resumo, um agente de interface, “ao contrário de outros tipos de agente, é o que
usa técnicas de aprendizado para apresentar ações de interface pseudo-inteligentes” (FONER, 1993
apud NWANA, 1996).
Segundo Costa (1999), há um grande número de aplicações na Internet que dizem possuir a
habilidade de aprendizado e, normalmente, estes agentes estão relacionados com recomendação de
serviços, tais como livros ou músicas. Nwana (1996) cita vários exemplos de uso de agentes de
interface, tais como: agentes de interface como assistentes de agenda (KOZIEROK e MAES, 1993
apud NWANA, 1996), guias (LIEBERMANN, 1995 apud NWANA, 1996), ajudantes para controle
de tarefas (RHODES e STARNER, 1996 apud NWANA, 1996), ajudantes na filtragem de
informação (SHETH e MAES, 1993 apud NWANA, 1996), ajudantes para encontro de padrões
(FONER, 1996 apud NWANA, 1996), compra e venda em seu interesse (CHAVEZ e MAES, 1996
apud NWANA, 1996) e para entretenimento (MAES, 1995b apud NWANA, 1996).
2.3.5 Agentes de interface pedagógicos
Segundo Bigus e Bigus (2001) a interação com o computador hoje em dia se dá por meios
não naturais. O autor diz que uma interação natural seria por meios de linguagem, expressões
faciais e linguagem corporal, e uma linguagem simplesmente textual pode não detectar sarcasmos,
referências literárias e figurativas.
Personagens gráficos se tornaram importantes, como assistentes que aparecem na tela para
ajudar e dar auxílio sensível ao contexto. Estes personagens mudam de expressão a medida que o
usuário interage com o computador, piscam os olhos e chamam a atenção quando se passa o mouse
sobre eles. Um programa com estes personagens para interação tem uma abordagem moderna, pois
eles mostram como será a interação entre humanos e computadores daqui a algum tempo (BIGUS e
BIGUS, 2001).
30
Segundo Pereira e Geyer (1999), a tecnologia de agentes tem sido incorporada na
modelagem do STI e nos ambientes educacionais na Internet. O agente, no STI, teria uma intenção
além de simplesmente guiar o aluno no melhor uso do programa, mas também orientar o aluno
pedagogicamente sobre o domínio da aplicação. Tem-se então a missão de fazer o agente saber o
que está ensinando, definir estratégias de como melhor ensinar, e perceber se o aluno aprendeu ou
não.
Para melhorar a interação humano-computador (BIGUS e BIGUS, 2001) estes personagens
gráficos podem usar de recursos como animação, sons e texto, originando os agentes pedagógicos
animados. Segundo Johnson (1998), agentes pedagógicos animados são “personagens animados que
facilitam o aprendizado em ambientes de aprendizado baseados em computador”. O autor conceitua
claramente a idéia de um personagem ajudando o aluno ao longo do STI. Johnson (1998) especifica
também que os agentes animados respondem as ações do usuário, tendo conhecimento o suficiente
do contexto de aprendizado e do domínio que está sendo demonstrado a ponto de apresentar
atuações relevantes no contexto de aprendizagem.
Agentes pedagógicos animados são fortemente baseado em pesquisas prévias sobre STI,
porém, mesmo assim, trazem uma perspectiva diferente na facilitação de aprendizado on-line. O
fato deste tipo de agente ser autônomo faz com que eles herdem características dos agentes
autônomos de outras aplicabilidades, devendo exibir um comportamento no qual se leva em conta
ambos, os estudantes e o ambiente de aprendizagem (JOHNSON, 1998).
Ritter (1997 apud JOHNSON, 1998) verificou que o contraste de um STI com um
personagem em sua interface diante de um que ignora esse tipo de abordagem é descrito como uma
falta de interação do usuário no programa. É também verificado, como no trabalho de André et al.
(1998 apud JOHNSON, 1998), que os personagens animados fazem com que aprendizes sintam o
material utilizado na educação computacional menos difícil. Lester et al. (1997 apud JOHNSON,
1998) fala do aumento da motivação e da atenção dos estudantes. É fundamental, porém, a
possibilidade que os agentes pedagógicos animados dão de melhor modelar diálogos e interações
que ocorrem durante o aprendizado (JOHNSON, 1998).
Segundo Giraffa e Viccari (1998), agentes pedagógicos são entidades cujo propósito
fundamental é a comunicação com o aluno, a fim de realizar eficientemente a função de tutor, como
parte da missão pedagógica do sistema. A abordagem de agentes em STI possibilita interações mais
naturais e mais próximas entre alunos e o sistema tutor, onde a iniciativa da interação é
31
normalmente compartilhada entre o sistema e o aluno. Tais interações são um contraste preciso com
os documentos estáticos, que geralmente são encontrados em materiais de cursos baseados na
Internet.
Segundo Santos et al. (2001), os agentes pedagógicos atuam como monitores, que observam
as ações dos alunos e os ajudam durante o seu aprendizado. Além disso, eles trocam informações
com o aluno, a fim de adaptar a apresentação do conteúdo conforme o modelo ideal do aluno,
supervisionando o ambiente de aprendizado. O objetivo central destes agentes é contribuir para uma
aprendizagem efetiva do aluno, gerando um ganho de qualidade, sob o ponto de vista pedagógico,
para o ambiente onde estão inseridos. Sendo assim, eles caracterizam-se por (SANTOS et al.,
2001): guiar o aluno durante a interação com o sistema; monitorar as atividades do aluno,
fornecendo auxílio em situações críticas; registrar informações necessárias à modelagem do perfil
do aluno; selecionar estratégias de ensino adequadas, com base no perfil do aluno; motivar o aluno
a aprender; e prover interatividade ao sistema, oferecendo aos alunos a idéia de ter um amigo tutor
que lhes fornecerá ajuda.
Ahmed, Kassim e Ranganath (2001) dizem que agentes pedagógicos, como agentes
autônomos que incorporam características de agentes de tarefa específica e de entretenimento,
podem ser divididos em duas categorias: orientado por objetivos descritos na Tabela 2 ou orientado
por utilidade. O agente orientado por utilidade é utilizado para vários propósitos, como ajudar os
alunos a encontrar referências e materiais de aprendizado, agendar aulas em grupo, lembrar o prazo
limite de entrega de relatórios, etc.
Tabela 2. Características de agentes pedagógicos baseados em objetivos
Tutor Mentor Assistente Conhecimento sobre o ambiente
Forte Forte Média
Conhecimento sobre o domínio
Forte Forte Forte
Modelo do aluno Forte Média Fraca Aspectos pedagógicos Forte Média Fraca
Fonte: Adaptado de Ahmed, Kassim e Ranganath (2001).
Ahmed, Kassim e Ranganath (2001) em suas pesquisas perceberam que os agentes
pedagógicos têm alguns atributos desejáveis que seu projetista deve procurar implementar. Algumas
32
destas características são, em geral, desejáveis em todos os tipos agentes, porém aqui elas são vistas
com um enfoque pedagógico, sendo elas:
• Autonomia: deve realizar a maioria de seus problemas de resolução de tarefas sem a
intervenção direta de um humano ou outro agente. Ele deve ter um certo grau de controle
sobre seus próprios atos e estados internos;
• Reatividade: o agente deve ser reativo a partir do momento que eles são habilitados a
sentir mudanças no ambiente e responder dentro de um certo período de tempo;
• Orientação por objetivo: deve ter pro-atividade e exibir comportamentos orientados por
um objetivo através da iniciativa;
• Comunicação: deve responder aos aprendizes com uma combinação de comunicação
verbal e gestos não-verbais como apontar, posicionar o corpo e balançar a cabeça. Ele
pode demonstrar emoções como surpresa, aprovação e desapontamento;
• Efeito visual: eles devem dar a impressão de serem vivos e de verdade, interagindo com
o usuário em uma base contínua;
• Afetividade: eles devem demonstrar expressão emocional nas interpretações faciais,
gestuais e de linguagem corporal. A expressão emocional é importante porque tem
influência no processo cognitivo do aluno;
• Servir em nome de alguém: Agir na maioria das vezes em nome do tutor;
• Adaptativo: agir de acordo com o estado cognitivo do aprendiz; e
• Capacidade social: capaz de se comunicar com humanos e outros agentes através de uma
linguagem de comunicação que satisfaça seus objetivos de design.
2.3.6 Arquitetura de STI utilizando agentes
A arquitetura do sistema tutor inteligente desenvolve-se inserindo um agente pedagógico de
interface em um STI para o ensino computacional. Segundo Viccari e Giraffa (2003), “modelar um
STI utilizando agentes é mais do que uma abordagem generalista e deve considerar que
teoricamente não temos um limite para o número de agentes que podem participar do processo”. Na
Figura 14, Santos et al. (2001) apresentam um exemplo de arquitetura, utilizado na sua agente
Dóris.
33
Figura 14. Arquitetura baseada em agentes
Fonte: Santos et al. (2001).
Na arquitetura de Santos et al. (2001), o agente pedagógico é inserido em um ambiente de
ensino computacional que utiliza um STI para o aprendizado de um domínio específico, refletindo
os seguintes módulos: perceptivo, cognitivo e reativo. A arquitetura do agente envolve, ainda, uma
base de conhecimento interna.
O módulo perceptivo é o responsável pela extração e armazenamento das informações
referentes à interação do aluno com o sistema. É através dele que é realizada a tarefa de
monitoração das ações do aluno. O módulo cognitivo é o responsável por realizar as inferências
sobre a base de conhecimento, determinando quais ações devem ser executadas pelo agente, a partir
de suas percepções. É através deste módulo que é feita a escolha das mensagens que serão emitidas
pelo agente na sua interação com o aluno, bem como determinados os recursos áudio-visuais a
serem utilizados. O módulo reativo é o responsável por executar as ações indicadas pelo módulo
cognitivo e estabelece a interface animada com o aluno. É através deste módulo que são
efetivamente apresentadas as mensagens e animações do agente aos alunos.
A base de conhecimento é onde todas as informações pertinentes do sistema são
armazenadas, tais como:
• Recursos áudiovisuais: formada pelos elementos usados para formar a aparência do
agente;
• Conteúdos: contém informações sobre os conteúdos das aulas;
• Respostas do aluno: contém as respostas às perguntas feitas ao aluno; e
34
• Mensagens: contém perguntas, dicas e lembretes utilizados pelo agente na interação com
o aluno.
Outra proposta de arquitetura é a de Giraffa (1999 apud VICCARI E GIRAFFA, 2003) no
seu STI chamado MCOE, que pode ser visto na Figura 15. Ele trata a base do domínio do STI
através de um cenário interativo onde as ações dos alunos transcorrem de forma dinâmica e com
resposta imediata. Ele modela o domínio no que chama de SMAR (Sistema Multi-Agente Reativo),
sendo utilizados agentes reativos, pois eles permitiriam uma leitura direta do que está acontecendo
no ambiente.
O SMAR é composto dos elementos do cenário do jogo, constituindo-se de um conjunto de
entidades simples (agentes reativos) que não possuem representação no seu ambiente. Já seu kernel
cognitivo é baseado num modelo organizacional humano mantendo uma representação explícita do
seu ambiente e de outros agentes da sociedade.
Figura 15. STI com arquitetura usando agente
Fonte: Adaptado de Giraffa (1999 apud VICCARI E GIRAFFA, 2003).
2.3.7 Exemplos de STI utilizando agentes
Nos últimos 10 anos a utilização de agentes pedagógicos animados tem se tornado muito
popular. Nesta seção será feita uma pequena descrição de alguns exemplos de agentes pedagógicos
implementados e seus atributos.
2.3.7.1 Herman-the-Bug
Herman-the-Bug (LESTER e STONE, 1997) é um agente que aparenta vida cujas ações
visuais e verbais são controladas por um seqüenciador de comportamento em tempo real para
resolver contextos de solução de problemas. Ele realiza uma vasta quantidade de atividades, que
35
incluem andar, voar, nadar, encolher, expandir e acrobacias. Ele habita um ambiente de aprendizado
chamado Design-a-Plant, cujo domínio é de anatomia e fisiologia botânica.
2.3.7.2 Cosmo
Cosmo (LESTER et al., 1997) é uma personagem 3D que atua num papel de aconselhador
da Internet em um ambiente de ensino para o domínio de roteamento de pacotes para Internet.
Cosmo é designado para o estudo de agentes num âmbito espacial, ou seja, a habilidade de agentes
de, dinamicamente, combinar gestos, locomoção e fala para se referir a objetos no ambiente
enquanto eles entregam o conselho para a resolução do problema.
2.3.7.3 Adele
O agente Adele (SHAW et al., 1999) foi desenvolvido para operar através da Internet. A
arquitetura deste agente implementa funções pedagógicas essenciais como: apresentação,
monitoramento do estudante, questões de sondagem e feedback, dicas e explicações. Os cursos
baseados no agente Adele estão atualmente sendo desenvolvidos para educação médica em
medicina familiar e no nível de graduação para odontologia geriátrica.
O Sistema Adele consiste em quatro componentes principais: o agente pedagógico, a
simulação, o cliente e o servidor, e o servidor de armazenamento. O agente pedagógico, mostrado
na Figura 16, consiste de mais dois sub-componentes, o personagem animado e um motor de
raciocínio.
Figura 16. O agente Adele, explicando a importância de certos procedimentos
Fonte: Shaw et al. (1999).
36
2.3.7.4 Steve
Steve (RICKEL e JOHNSON, 1997), é uma personagem em 3D que auxilia alunos em
ambiente de imersão em rede e tem sido aplicado para treinamento de tarefas navais como a
operação de motores abordo de navios da marinha dos Estado Unidos. O sistema no qual o Steve foi
inserido permite múltiplos estudantes e agentes para co-habitar num mundo virtual. Cada estudante
é imerso em um ambiente através de equipamentos especiais, e vêem o mundo através de um
display acoplado em suas cabeças, chamado HMD (Head-Mounted Display).
2.3.7.5 Guilly
O agente Guilly (NUNES et al., 2002) trabalha dentro do Intelligent Virtual Teaching
Environment, implementado com tecnologias multi-agentes e utilizando características
pedagógicas. Este agente foi desenvolvido para ensinar crianças de 8 a 10 anos sobre a preocupação
de selecionar corretamente o lixo urbano.
Ele tem como características interessantes algumas reações, como, por exemplo, quando o
aluno está respondendo questões ou agindo corretamente ele usa moderadamente somente
expressões faciais e de corpo, porém ao identificar um comportamento ruim do aluno ele utiliza,
além da face e do corpo, sons e texto (NUNES et al., 2002).
Figura 17. O agente Guilly
Fonte: Nunes et al. (2002).
2.4 Sistema Especialista (SE)
Segundo Savaris (2002) a palavra “sistema” significa um “conjunto de elementos, materiais
ou ideais, entre os quais se possa encontrar ou definir alguma relação”, e a palavra “especialista” se
refere a “uma pessoa que se consagra com particular interesse e cuidado a certo estudo” ou,
37
resumidamente, um “perito” de uma determinada disciplina. Sistemas especialistas são “sistemas
que solucionam problemas que são resolvíveis apenas por pessoas especialistas (que acumularam
conhecimento exigido) na resolução destes problemas” (SAVARIS, 2002). São sistemas
computacionais criados para “resolver problemas e que devem apresentar um comportamento
semelhante a um especialista em um determinado domínio, cujo conhecimento utilizado é fornecido
por pessoas que são especialistas naquele domínio” (SAVARIS, 2002).
A inteligência do agente deste TCC se dá pelo uso de um sistema especialista, pois a idéia
de orientação vinda do agente se baseia em algumas várias observações feitas, tais como “o aluno já
visitou a correlação clínica?”. Estas regras são do tipo “se <condição envolvendo fatos> então”, o
que se encaixa no perfil da técnica de regras do sistema especialista. Esta também já era a técnica
escolhida pelo projeto “Sistemas Virtuais de Ensino Baseados na Internet para Suporte à Educação
e Treinamento na Área de Saúde”, no qual este TCC está inserido, e é descrito na Seção 3.1.
Para validação e verificação das regras no sistema é necessário utilizar um motor de
inferência. Neste projeto está sendo utilizado o Expert Sinta (LIA/UFC, 1996) para validação e o
CLIPS para implementação das regras. Tais ferramentas, também chamadas de expert system shell,
são softwares que combinam fatos e regras de modos diversos, embutem uma máquina de
inferência específica, assim como uma representação própria de conhecimento, e permitem a
construção de sistemas especialistas que utilizem a sua representação de conhecimento e máquina
de inferência (MOURA e CRUZ, 2001).
Um sistema especialista é um programa projetado para modelar a habilidade de resolver
problemas que segue o esquema apresentado na Figura 18, composto das seguintes partes
(DURKIN, 1984 apud MOURA e CRUZ, 2001):
• Base de Conhecimento: parte contendo o conhecimento do domínio, ou seja, as regras de
produção obtidas para o sistema;
• Memória de Trabalho: parte contendo os fatos sobre os problemas que são descobertos,
concluídos, em uma sessão de execução; e
• Máquina de Inferência: processo que combina os fatos da memória com a base de
conhecimento para chegar às conclusões sobre o problema.
38
Figura 18. Sistema Especialista
Fonte: Durkin (1984 apud MOURA e CRUZ, 2001).
Este TCC levou em conta o estudo de ferramentas de sistema especialista, tendo como
intuito utilizar a ferramenta que mais se adequasse aos requisitos do projeto. O sistema especialista
para este projeto foi implementado de acordo com os seguintes requisitos:
• Ser compatível com a linguagem Java (SUN, 2006b);
• Ser possível seu uso pela Internet; e
• Ser de uso livre. Para ser de uso livre um software deve ter as licenças comuns de uso
livre, por exemplo, GNU (GNU is Not Unix) (FREE SOFTWARE FOUNDATION,
2006a) ou GPL (General Public License) (FREE SOFTWARE FOUNDATION, 2006b).
Inicialmente o projeto optou em utilizar o JESS (Java Expert System Shell) (JESS, 2006),
desenvolvido pela Sandia National Laboratories, nos Estados Unidos, porém seu uso foi
desconsiderado quando identificou-se que sua licença não era livre. Sendo assim, as ferramentas
encontradas até o momento para estudo foram:
• CLIPS (C Language Integrated Production System): um expert system shell que tem
sido desenvolvido pela NASA (National Aeronautics and Space Administration) desde
1985 (RILEY, 2005);
• WebCLIPS: CGI (Common Gateway Interface) para o CLIPS, desenvolvido por
Michael Giordano (GIORDANO, 2003); e
39
• JCLIPS (CLIPS for Java): Ponte em software entre o Java e o CLIPS, desenvolvido por
Maarten Menken (MENKEN, 2005).
2.4.1 Shells estudadas
Nesta subseção serão apresentadas as ferramentas avaliadas no processo de escolha do
sistema especialista a ser utilizado.
2.4.1.1 CLIPS
O CLIPS é uma ferramenta que permite o total desenvolvimento de sistemas especialistas
baseados em regras. Ele pode ser embutido em código procedural, chamado como uma sub-rotina, e
integrado com linguagens como C, Java e FORTRAN (Formula Translator). Ele é facilmente
extensível através do uso de protocolos já fortemente definidos (RILEY, 2004).
O CLIPS é desenvolvido na linguagem C, implementando o algoritmo Rete em sua máquina
de inferência e tendo como preocupação principal a portabilidade entre vários sistemas
operacionais, o que se torna uma das suas grandes vantagens. Ele compila em vários sistemas
operacionais, incluindo o Linux que já é usado no ambiente do STI utilizado para o
desenvolvimento do agente. Como já dito, o fato de ele ser desenvolvido em C não impede um
possível encapsulamento em Java, pois ele pode ser compilado como uma biblioteca. (RILEY,
2004).
A documentação para orientação de uso do CLIPS é abrangente e orienta a utilização sob
vários aspectos, desde a construção de sistemas especialistas até a expansão do CLIPS e seu
encapsulamento em outras ferramentas de desenvolvimento. Não há custo de distribuição, a
utilização é gratuita e deve apenas ser feito um registro de uso on-line (RILEY, 2004).
O CLIPS funciona permitindo a entrada de regras e fatos através de código armazenado em
arquivos texto com a extensão “.clp” ou com código digitado no próprio console que é fornecido
juntamente com a biblioteca.
2.4.1.2 WebCLIPS
O WebCLIPS cria uma interface CGI do CLIPS para a Internet, fornecendo uma
comunicação com a Web. O WebCLIPS é implementado em C e há versões para plataformas UNIX
e Windows. Sua distribuição é gratuita e ele se encontra sob licença GNU (GIORDANO, 2003).
40
Inicialmente o WebCLIPS demonstrava ser uma ferramenta promissora com possibilidade de
utilização no projeto por ser feita exatamente para uso na Internet, porém sua pouca flexibilidade
para a comunicação com Java desencorajou seu uso.
Os scripts rodados em WebCLIPS devem atender as mesmas especificações do CLIPS,
tendo como único elemento incomum o fato dos resultados obtidos no WebCLIPS terem algumas
tags HTML incluídas para a amostragem apropriada no navegador Web (GIORDANO, 2003). As
páginas e formulários são gerados dinamicamente em HTML pelo WebCLIPS, sendo que, para isso,
ele obtém as informações vindas das variáveis “GET” e “POST”, da requisição enviada ao servidor.
Para informações perenes, esta ferramenta permite salvar o status do cliente em cookies.
Seu funcionamento se dá no momento que uma requisição é feita ao CGI. A partir dela o
WebCLIPS identifica qual o arquivo de regras que deve ser usado, e tenta montar os fatos vindos da
requisição, e verifica se este mesmo cliente já não tinha fatos armazenados no servidor em um
cookie. Os fatos então são carregados e o CLIPS é iniciado e o processamento das regras e dos fatos
é feita. Depois da máquina de inferência terminar o seu trabalho, o sistema então atualiza sua
memória de trabalho com os resultados, monta e envia a saída com os devidos comandos HTML
para o cliente.
2.4.1.3 JCLIPS
JCLIPS é um software livre, sob licença GNU, que permite programadores Java usarem o
CLIPS em combinação com Java através da incorporação do motor CLIPS em uma classe Java.
Sendo assim, torna-se possível controlar o motor CLIPS através do Java, podendo-se então carregar
arquivos CLIPS, executar o motor, executar comandos arbitrários, e receber informações de volta
do CLIPS no formato texto (MENKEN, 2005). O JCLIPS pode ser embutido em uma aplicação
Java que seja entregue através de uma página Web via Applet (CRIGHTON, 2005).
As aplicações são escritas normalmente em Java e utilizam-se dois arquivos JCLIPS (um
“.dll” e um “.jar”) para estabelecer sua ponte entre Java e CLIPS. O arquivo “.dll” contém toda a
distribuição CLIPS compilada pra Windows, assim não é necessário obter o CLIPS separadamente.
O arquivo “.jar” completa a parte Java desta ponte. O JCLIPS é conhecido por rodar em ambas as
plataformas Windows e Linux (MENKEN, 2005).
A integração do JCLIPS com qualquer aplicação Java se dá adicionando os arquivos
contendo a classe Java e a biblioteca CLIPS em um mesmo diretório do classpath Java, ou
41
adicionar o diretório da aplicação e do arquivo na variável de ambiente classpath, utilizada pelo
Java. A classe a ser instanciada chama-se “JClips” (MENKEN, 2005).
Esta classe contém os métodos para configuração e controle do ambiente CLIPS. O CLIPS
pode enviar mensagens de retorno ao Java. Isto é feito chamando uma função definida pelo usuário
no Java, que tem a mensagem de retorno como argumento de entrada (MENKEN, 2005).
Só é possível um ambiente CLIPS rodando simultaneamente e, portanto, uma única
instância dessa classe é automaticamente criada e uma referência pode ser obtida através do método
“getInstance”. Não é possível criar mais instâncias (MENKEN, 2005).
2.4.2 Ferramenta escolhida
A ferramenta de sistema especialista escolhida para o desenvolvimento do agente foi a
JCLIPS. O JCLIPS levou em conta os requisitos básicos de fácil acoplamento com Java e de
software livre. A Tabela 3 apresenta um comparativo entre as ferramentas estudadas.
Tabela 3. Comparação das shells
Ferramenta Compatível com Java
Linguagem Documentação Licença
CLIPS Sim, mas requer esforço extra de programação para encapsulamento
CLIPS Boa Livre
WebCLIPS Não CLIPS, com inclusão de tags HTML
Média Livre
JESS Sim JESS, fortemente baseada na linguagem CLIPS
Boa Paga
JCLIPS Sim CLIPS + Java Regular Livre
A deficiência na documentação específica para JCLIPS não se sobressai aos outros itens,
isso porque boa parte da documentação do CLIPS (informações da linguagem de especificação das
regras, informações sobre funcionamento, etc.) se aplica ao uso do JCLIPS.
O JCLIPS, então, foi escolhido como ferramenta por ter uma interação completa com o
CLIPS, fácil instalação e suas restrições em relação às ferramentas pagas não vão de encontro aos
objetivos e necessidades do projeto. Além disso, o CLIPS é conhecido por sua segura
implementação do algoritmo de Rete para resolução dos fatos e regras do sistema especialista.
42
2.4.3 Algoritmo de Rete
As linguagens baseadas em regras, ou sistemas especialistas, usam um algoritmo bastante
eficiente para unificação dos padrões das regras a fim de determinar quais regras têm seus
antecedentes satisfeitos, chamado Algoritmo de Unificação de Padrões de Rete (GAIRRATANO e
RILEY, 1989 apud FERNANDES, 1996). Este foi o algoritmo utilizado neste projeto.
O problema tratado por este algoritmo, ilustrado na Figura 19, é o do processo de unificação
dos padrões das regras. Caso a unificação ocorrer apenas uma vez, a solução se torna mais simples.
A máquina de inferência pode examinar cada regra e, então, procurar o conjunto de fatos que
determinam se os padrões da regra serão satisfeitos. Se os padrões das regras são satisfeitos então a
regra pode ser colocada na agenda (FERNANDES, 1996).
Figura 19. Unificação de padrões: fatos e regras
Fonte: Adaptado de Fernandes (1996).
Porém nos sistemas especialistas o processo de unificação ocorre repetidamente (Figura 20),
e a lista de fatos é, em geral, modificada a cada ciclo de execução, tendo novos fatos adicionados ou
velhos removidos. Essas modificações podem fazer com que regras que antes não eram satisfeitas
agora se tornem satisfeitas e vice-versa (BROWNSTON, 1985 apud FERNANDES, 1996).
43
Figura 20. Recursos computacionais desnecessários quando as regras procuram fatos
Fonte: Adaptado de Fernandes (1996).
A técnica do algoritmo de Rete inicia com a seguinte conclusão: os fatos devem procurar as
regras, e não as regras procurarem fatos (Figura 21). Isso porque é comum as regras alterarem
apenas alguns poucos fatos da lista de fatos a cada ciclo de execução e seria desnecessário e
demorado cada regra correr toda a lista de fatos a cada ciclo, como demonstrado pela área
sombreada na Figura 20. Deve-se então reduzir esta chamada redundância temporal
(FERNANDES, 1996).
Figura 21. Fatos em busca de regras
Fonte: Adaptado de Fernandes (1996).
O algoritmo de unificação de padrões Rete foi projetado para tirar vantagem da redundância
temporal que existe em um sistema especialista baseado em regras (FORGY, 1985 apud
FERNANDES, 1996). Ao invés de buscar as semelhanças dos fatos em todas as regras em todos os
44
ciclos de reconhecimento das ações, o algoritmo Rete somente procura por trocas semelhantes em
todos os ciclos, o que faz o algoritmo de Rete muito veloz (MAIA, 1998).
Realiza-se então um armazenamento da informação obtida sobre a aplicação das regras,
fazendo com que cada regra lembre quais fatos usou, e apenas atualiza os fatos processados na lista
de fatos a cada novo ciclo (FERNANDES, 1996; MAIA, 1998). O estado do processo de unificação
é armazenado a cada ciclo, recalculando as mudanças de um estado apenas para estados ainda não
encontrados.
O algoritmo de Rete então faz alusão ao princípio da similaridade estrutural, referindo-se ao
fato de que muitas regras podem conter padrões ou grupo de padrões similares, colocando
componentes juntos de maneira que eles não sejam considerados mais de uma vez. O fato de o
algoritmo armazenar o estado do sistema especialista, entretanto, pode intensificar o consumo de
memória (FERNANDES, 1996).
45
3 DESENVOLVIMENTO
Neste capítulo será esclarecido o processo de desenvolvimento deste projeto, que
implementou um agente pedagógico para um sistema tutor inteligente da área de Neurofisiologia,
implementado dentro do projeto “Sistemas Virtuais de Ensino Baseados na Internet para Suporte à
Educação e Treinamento na Área de Saúde”, onde cada seção descreve uma das partes do projeto.
A Seção 3.1 contextualiza as intenções do projeto, indicando também a equipe que o
idealizou e as pessoas envolvidas. A Seção 3.2 descreve o comportamento do agente no STI e a
Seção 3.3 apresenta o processo de desenvolvimento do conceito visual do agente, este último
trabalho realizado pela equipe de design do projeto.
A Seção 3.4 apresenta a estrutura da arquitetura de comunicação e a Seção 3.5 apresenta
como foi o desenvolvimento de cada um desses passos. Na Seção 3.6 tem-se a descrição do
desenvolvimento das regras de produção e na seção 3.7 os diagramas UML (Unified Modeling
Language).
3.1 Portal Saúde+Educação
O portal Saúde+Educação, desenvolvido pelo projeto “Sistemas Virtuais de Ensino
Baseados na Internet para Suporte à Educação e Treinamento na Área de Saúde” do IEB (Instituto
de Engenharia Biomédica) fomentado pela FINEP (Financiadora de Estudos e Projetos) (FINEP,
2006), englobou a construção de um STI na área de Neurofisiologia. O portal foi desenvolvido
através de uma parceria do IEB da UFSC (Universidade Federal de Santa Catarina), da UCB
(Universidade Católica de Brasília), da Mediasoft e da UNIVALI.
Como mostrado na Figura 22, a equipe de desenvolvimento do portal se subdividiu,
chegando a uma equipe específica, alheia ao desenvolvimento desta monografia, que desenvolveu e
programou o STI. Já o desenvolvimento do agente pedagógico se deu em parceria com um designer,
que idealizou e desenhou o personagem do agente pedagógico, e uma analista, que criou as regras
de comportamento do agente. Este TCC, então, refere-se ao desenvolvimento da arquitetura e
análise do motor de verificação de regras para o agente pedagógico, e sua acoplagem ao STI de
neurofisiologia já desenvolvido pelo projeto.
46
Quanto às tecnologias e ferramentas escolhidas, o projeto preza por utilização de
ferramentas de uso livre, portanto utiliza a linguagem Java (SUN, 2006b), com as técnicas de JSP
(Java Server Pages) (SUN, 2006c) e JSF (Java Server Faces) (SUN, 2004), o banco de dados
PostgreSQL (POSTGRESQL, 2006) e o sistema operacional OpenSUSE Linux (Open Software und
System Entwicklung) (NOVELL, 2005).
Figura 22. Organização simplificada do projeto
O STI oferece acesso aos conteúdos relacionados à neurofisiologia, onde o aluno estudante
acessará cada um dos tópicos do tutorial. Todo tópico é dividido em itens, descritos a seguir:
• Mão na Massa: ao selecionar este item o sistema exibe um desafio prático para o aluno
resolver. Neste ambiente o aluno entra em um ambiente 3D munido de ferramentas onde
ele pode fazer experimentos com objetos e itens do contexto de Neurofisiologia;
• Correlação Clínica: neste item o aluno encontra informações relacionadas à prática
clínica;
• História: neste item é exibida a contextualização histórica do tópico selecionado; e
• Auto-Avaliação: o sistema permite ao aluno a realização de uma auto-avaliação, que
consiste de questões objetivas diversas apresentadas aleatoriamente.
47
Além desses itens principais, tem-se: o Glossário, que permite ao aluno redigir uma palavra
chave e o sistema exibe o seu significado; a Ajuda, contendo uma explicação de como operar o
sistema; o Chat, que permite a comunicação síncrona dos alunos no ambiente; e o Fórum, que
permite a comunicação assíncrona.
3.2 STI e agente pedagógico
O agente pedagógico deste STI tem como objetivo maximizar o desempenho do aluno nas
auto-avaliações do STI. Para chegar-se nesse objetivo, a construção do agente pedagógico levou em
consideração algumas informações obtidas no sistema, com o registro dos acessos do aluno dentro
do STI, o que permite que o agente saiba quais os itens que o aluno já visualizou, para então
orientá-lo no caso de um mau desempenho na auto-avaliação.
O conteúdo está dividido pelos conteudistas em tópicos, cada tópico foi dividido em itens e
cada item foi dividido em sub-itens. As questões da auto-avaliação foram formuladas baseando-se
nos tópicos e seus itens, ou seja, cada questionário será formado de questões sobre o tópico. Ao
clicar na auto-avaliação o sistema seleciona dez das perguntas cadastradas para o tópico em que o
aluno atualmente se encontra. A avaliação é gerada dinamicamente e a mesma avaliação não se
repetirá para o mesmo aluno.
Após a realização da auto-avaliação o sistema retorna ao usuário, através do agente, o seu
desempenho. E, em caso de desempenho baixo, o agente pedagógico apresenta alternativas a fim de
reforçar a aprendizagem. As alternativas apresentadas pelo agente, levam em conta o que o aluno já
acessou, incluindo os itens Mão na Massa, Correlação Clínica e História.
Toda a comunicação do tutorial para o aluno se dá através do agente, e as falas principais do
agente pedagógico não são repetidas. Tudo isso para dar a idéia de um agente que seja um real
companheiro de aprendizagem, animado e com vida.
3.3 Concepção visual do agente pedagógico
A primeira versão do aspecto visual do agente foi dada por uma personagem feminina,
denominada “Luciana”, que foi substituída devido à baixa aceitação na comunidade científica pelo
fato de conter características que não condiziam com profissionais da área de saúde e por ter uma
imagem considerada polêmica, como, por exemplo, roupa muito extravagante. A modelagem e
implementação do personagem que compõe o agente proposto chegou então a sua segunda versão,
48
que foi denominado “Bernardo”, e levou em conta as seguintes características (FERNANDES et al.,
2006):
• Possuir expressões faciais dos mais variados sentimentos como alegria, admiração,
tristeza, entre outros; expressando emoções de acordo com o momento, não
interrompendo o usuário em seu aprendizado com intervenção escrita ou falada;
• Falar e escrever, usando balões de texto e/ou recursos de som, gesticular e ter reações
diversas para não tornar a interação com o usuário monótona. Por exemplo, usar a
comunicação escrita num primeiro contato, na segunda abordagem dar um sorriso ou
dicas;
• Ser simpático e prender a atenção do usuário.
As características abrangem também o fato do desenho seguir um estilo cartoon, sendo
menos preso a personificação de feições reais do ser humano. O estilo do desenho não deve levar
em conta luz para então ter um ar menos “formal”. O contorno dos membros do personagem
reafirma essa proposta, juntamente com o uso de cores vivas em suas vestimentas, que são trocadas
de acordo com a situação, como visto na Figura 23.
Figura 23. O agente “Bernardo”
3.4 Funcionamento do Agente
A arquitetura de comunicação se dá com uma animação em SWF (Small Web Format)
embutida num frame HTML na parte cliente, gerado pelo JSP. Essa animação então se comunica
por requisições ao servidor para o processamento de regras no JCLIPS e busca de diálogos e sons,
como demonstrado na Figura 24. A escolha do formato SWF se dá pela sua facilidade de lidar com
gráficos, sons, texto e interações em interfaces Web o que é imprescindível para a personagem
49
gráfica do agente e suas feições. Arquivos neste formato são desenvolvidos com a ferramenta
Macromedia Flash (MACROMEDIA, 2004a).
Na Figura 24 tem-se a seta “verifica interações do aluno” e a seta “atua”, que indicam a
parte da arquitetura de comunicação que interage diretamente com o navegador Web do aluno. Esta
interação é possível graças ao formato SWF, que também possui uma forte linguagem de
programação, chamada ActionScript (MACROMEDIA, 2004b), e que permite a personagem
gráfica do agente observar o ambiente HTML (sensores) através da comunicação direta com o
Javascript (REFSNES DATA, 2006b) e conversar com o usuário através de sons, desenhos,
animações e textos (atuadores). A seta “grava”, também na Figura 24, faz relação à gravação e
obtenção das informações do aluno necessárias para a posterior inferência das regras.
Figura 24. Arquitetura do agente “Bernardo”
A seta “carrega” indica que o agente identificou (capturou pelo sensor) que o aluno clicou
em algum item e comunicou ao navegador Web para que o navegador carregue o item
correspondente. Por último, a seta nomeada “infere regras” indica o momento em que o aluno
finalizou a realização da auto-avaliação. Ali o agente inicia a inferência das regras contidas em um
arquivo de regras no servidor (“Regras.clp”) sobre as informações do aluno existentes no banco de
dados (seta “grava”) e obtém a resposta do que fazer para orientar o aluno com estratégias de
aprendizado.
Somadas estas funcionalidades, pode-se observar no agente os seguintes sensores:
50
1. Integração Javascript/Actionscript: verifica as interações do aluno com o navegador
quanto à requisição de conteúdo;
2. Integração Javascript/Actionscript: verifica as interações do aluno com o navegador
quanto à realização de auto-avaliação; e
3. Identificador das estratégias vindas do JCLIPS: recebe e trata as respostas do JCLIPS.
Também se pode observar no agente os seguintes atuadores:
1. Integração Javascript/Actionscript: indica ao navegador qual conteúdo carregar quando
requisitado pelo aluno;
2. Exibidor de animações e texto no SWF: faz a atuação entre a personagem gráfica do
agente e o aluno, mostrando mensagens, caixas de diálogo e suas respectivas expressões
e gestos;
3. Gravador de informações do aluno: grava as informações obtidas do aluno no banco de
dados no servidor através de uma requisição HTTP (Hypertext Transfer Protocol) ao JSP
no servidor; e
4. Requisitor de estratégias do JCLIPS: requisita estratégias de ensino ao JCLIPS através
de uma requisição HTTP ao JSP no servidor, que por sua vez o repassa ao JCLIPS.
3.5 Implementação
Durante o desenvolvimento do agente algumas partes da arquitetura foram alteradas. Apesar
de a arquitetura ter sido discutida e estabelecida junto com a equipe de programadores do STI, o
STI ainda não havia sido programado efetivamente durante a modelagem do agente. Esta não
implementação influencia nos itens da arquitetura do agente (sensores e atuadores) e, em como o
agente será entregue ao cliente Web (navegador).
O STI e as regras, porém, não foram concluídos antes do início da implementação desta
arquitetura de agente, o que desencadeou a necessidade de utilizar um STI protótipo, em parte para
poder se testar a arquitetura. Este STI protótipo conta com o assunto dividido conforme a Figura 25.
A implementação do protótipo, assim como as regras, só têm abrangência até o elemento “item”.
Portanto caso um aluno tenha apresentado baixo desempenho no questionário, só lendo o item
“história”, o agente indicará a leitura de um outro item, conforme as regras indicarem.
51
Figura 25. Organização do assunto
Uma dúvida constante durante a modelagem foi se o agente em filme SWF agiria como uma
espécie de centralizador das atividades relacionadas à obtenção de conteúdo e gravação dos acessos
do aluno, ou se o STI se encarregaria de fazer esta operação. Caso o STI se encarregasse desta
operação o sensor número 1 e os atuadores números 1 e 3 deixariam de existir. No protótipo deste
TCC, porém, eles foram implementados. Uma imagem do protótipo pode ser visto na Figura 26.
Quanto à entrega do agente pela Web, inicialmente havia sido definido como sendo em um
frame HTML a parte contendo o filme SWF, mas que acabou sendo feito em um layer HTML, que
é uma camada flutuante sobre os outros itens da página. Isto porque o protótipo foi feito utilizando
um modelo que divide as áreas do STI usando a tecnologia de iframe (REFSNES DATA, 2006c), o
que não implica em um recarregamento completo da página a cada clique do usuário.
52
Figura 26. STI e o agente Bernardo
As feições do agente estão organizadas em um filme elaborado na ferramenta Macromedia
Flash. O Flash permite organizar, através de rótulos em seu “timeline” (ou linha de tempo), pedaços
específicos de filme, o que facilita a construção do agente e a estruturação de suas feições. O filme
então aciona, quando necessário, o servidor para executar o JCLIPS e ao receber a resposta, analisa
as variáveis resultantes e verifica a qual feição ela se refere. A feição correspondente é executada
através da função “gotoAndPlay”, do ActionScript (MACROMEDIA, 2004b).
Este filme com todas as feições é carregado por inteiro no início da aplicação com a
utilização de uma técnica chamada preloader, ou um carregador que mostra o filme sendo
carregado sem desestruturar a aplicação ou confundir o aluno. Exemplos das feições podem ser
vistos na Figura 27.
Para comunicação dentre os elementos da interface (mensagens do STI pro agente),
necessária para gravar quais páginas o aluno visualizou e quanto tempo ele ficou em cada página, o
Javascript utiliza métodos disponibilizados pelo objeto do Flash embutido no documento HTML,
como o “SetVariable()” que faz com o que o Flash armazene dados e informações enviadas pelo
Javascript no seu filme. O filme em Flash do agente, para gravar essa informação no servidor,
53
utiliza uma classe ActionScript chamada “LoadVars”. Essa classe envia e recebe requisições ao
servidor, possibilitando uma comunicação do agente com o JSP e JCLIPS, permitindo também
monitorar a transferência de informações.
Esta comunicação se dá atribuindo as variáveis a serem enviadas as propriedades de um
objeto da classe “LoadVars”, e estas propriedades são enviadas para o servidor através do método
“sendAndLoad()” existente nesta classe. A classe então fica esperando uma resposta do servidor,
que deverá enviar a seqüência de variáveis de resposta no mesmo formato da requisição GET, com
o nome da variável seguido de um símbolo de igualdade “=” e o respectivo valor dessa variável,
sendo que o caractere “&” é inserido no fim de o valor de uma variável indicando a separação entre
as mesmas, por exemplo “variavel1=valor1&variavel2=valor2&variaveln=valorn”.
Ao obter a resposta do servidor e finalizar a conexão com o mesmo, o objeto da classe
“LoadVars” que fez a requisição tem o seu evento “onLoad” disparado. O evento é uma função que,
tipicamente, trata estes resultados obtidos do servidor, que a classe automaticamente já decodifica
do formato de requisição GET para torná-los propriedades do objeto.
54
Figura 27. Feições do agente Bernardo
A configuração para se poder acessar o filme SWF através do Javascript requer a utilização
de uma propriedade chamada “swliveconnect” atribuída como “true”, ou “verdadeiro” em
português, já na inclusão do objeto Macromedia Flash na página HTML, para este funcionar em
navegadores que não iniciam esta comunicação automaticamente. Fazer com que esta comunicação
funcionasse nos dois navegadores mais utilizados atualmente, Internet Explorer (MICROSOFT
CORPORATION, 2006) e Mozilla Firefox (MOZILLA FOUNDATION, 2006) foi um problema
corrente durante a implementação. A soma da utilização destes dois navegadores chega, em média,
a 95% dos usuários Web (REFSNES DATA, 2006a).
Tratando das feições do agente, o tamanho do filme em Flash tem tamanho o suficiente para
mostrar o agente, suas feições, e o seu balão de diálogo, contendo os textos e as suas frases na qual
ele interage com o aluno. Para este filme não ocultar o texto e os componentes visuais do sistema
tutor, foi utilizada uma outra propriedade chamada “wmode”, também do objeto Macromedia Flash
na página HTML, com o valor “transparent”, ou “transparente” em português. Assim, o filme fica
transparente acima do texto, só cobrindo-o com os balões de diálogo quando necessários.
55
Já para o desenvolvimento da parte residente no servidor (Java e JSP) foi utilizado o
ambiente de desenvolvimento NetBeans (SUN, 2006d). O NetBeans é uma IDE (Integrated
Development Environment) de uso livre para desenvolvimento Java, desenvolvida pela Sun
Microsystems, desenvolvedora desta linguagem. O desenvolvimento JSP é facilitado nessa IDE por
ela incorporar o servidor Tomcat (APACHE SOFTWARE FOUNDATION, 2005), o que já
proporciona um ambiente de testes. O servidor Tomcat também é um projeto de uso livre, e que
provê soluções server-side, linguagens processadas pelo servidor, com o uso da linguagem Java.
No NetBeans, então, foi criado um projeto que utiliza a linguagem JSP. A linguagem JSP
funciona como outras linguagens orientadas a objeto como, por exemplo, o C++, onde se tem uma
linguagem de desenvolvimento com funcionalidades básicas e deve-se adicionar outros pacotes ao
código (os “includes”do C++, chamados “imports” no JSP) caso sejam necessárias funcionalidades
mais avançadas ou específicas. Este é o caso quando se tenta acessar o banco PostgreSQL. Ele foi
integrado ao JSP através de um pacote que implementa a funcionalidade de conexão e que é
“importado” pelo código JSP, permitindo acesso a funções de acesso ao PostgreSQL. O arquivo do
pacote está no formato JAR (Java ARchive), onde as classes Java são distribuídas, e é
disponibilizado na Internet pelo fabricante do banco.
As requisições SQL são feitas através dessa classe para contato do JSP com o banco, e
utilizada a interface JDBC (Java Database Connectivity), comum a acessos a banco através do Java.
O JDBC é um conjunto de classes e interfaces escritas em Java que faz o envio de instruções SQL
para qualquer banco de dados relacional, ampliando o que se pode fazer com Java e possibilita o
uso de banco de dados. Para cada banco de dados há um driver, ou interface, JDBC
(POSTGRESQL, 2005).
Durante sua utilização, porém, constataram-se algumas deficiências neste driver,
principalmente no momento da contabilização dos acessos dos alunos. Este driver JDBC de acesso
ao PostgreSQL não permite uma obtenção adequada do conjunto de dados.
Para poder se acessar os dados do conjunto de resultados deve-se utilizar o método “next()”,
chamado para mover o ponteiro que especifica qual linha do resultado será retornada, porém isto
torna cada linha retornada pelo banco acessível somente uma vez. Além disso, o driver não
disponibiliza um método que contribua para a contagem dos resultados. Uma solução seria navegar
por entre os resultados contabilizando-os, e depois retornar ao resultado inicial para acessá-los
novamente para extrair as informações, porém, como já dito, isto também não é possível. A
56
segunda, e definitiva, solução foi a extração dos dados para vetores do tipo “String” e a execução de
consultas extras ao banco de dados que retornassem o número de dados correspondentes, mesmo
não sendo uma solução ótima, pois algum dado poderia ser modificado entre a primeira e a segunda
consulta.
É necessário que o agente saiba todo o caminho e itens visualizados pelo aluno dentro do
STI, e que ele armazene esses dados para serem utilizados novamente em sessões futuras do aluno.
Então, para o armazenamento das informações obtidas do aluno (seta “grava” da Figura 24) foram
adicionadas ao servidor as seguintes tabelas de dados, sendo seus dicionários de dados mostrados na
Tabela 5, na Tabela 6, na Tabela 7 e na Tabela 8. Para manipulação do banco e criação de tabelas
foi utilizada a ferramenta pgAdmin (PGADMIN, 2006).
Tabela 4. Tabela de alunos
Campo Tipo de Dado Tamanho Descrição IdAluno Int (auto increment) 6 Chave primária Login Char 15 Nome de usuário do aluno
Senha Char 15 Senha do aluno Nome Char Seu nome PrimeiroLogin Bool Esta informação é necessária, pois
caso o aluno esteja entrando no sistema pela primeira vez o agente deverá apresentar o ambiente.
Tabela 5. Tabela de acessos dos alunos
Campo Tipo de Dado Tamanho Descrição IdAcesso Int (auto increment) 6 Chave primária IdAluno Int 6 Identifica o aluno que acessou o sistema IdTopico Int 6 Identifica o tópico que o aluno estava
visualizando idItem Int 6 Identifica qual item o aluno acessou (1 =
Conteúdo, 2 = História, 3 = Correlação clínica, 4 = Mão na massa)
Data Date A data de acesso Tempo Int 6 Tempo em minutos no qual o aluno ficou
lendo o texto.
57
Tabela 6. Tabela de itens
Campo Tipo de Dado Tamanho Descrição IdItem Int (auto increment) 6 Chave primária NumeroItem Int 6 1 = Conteúdo, 2 = História, 3 =
Correlação clínica, 4 = Mão na massa TempoMin Int 6 Tempo mínimo (em minutos) que o aluno
deverá ler este item para ser considerado um acesso
idTopico Int 6 Identifica a qual tópico este item se refere clipsRegra Char 50 Nome da variável CLIPS correspondente
a este item
Tabela 7. Tabela de questões
Campo Tipo de Dado Tamanho Descrição IdQuestao Int (auto increment) 6 Chave primária IdTopico Int 6 A qual tópico essa questão se refere Enunciado Text Enunciado da questão Opcao1 Char Primeira opção de resposta Opcao2 Char Segunda opção de resposta Opcao3 Char Terceira opção de resposta Opcao4 Char Quarta opção de resposta Figura Char O nome da figura a ser utilizada no
enunciado da questão (deixar em branco caso não existam figuras para esta questão)
Correta Int Qual a resposta correta
Tabela 8. Tabela de tópicos
Campo Tipo de Dado Tamanho Descrição IdTopico Int (auto increment) 6 Chave primária Nome Char 15 O nome do tópico
Para identificar a qual regra no CLIPS um item está relacionado, o nome da variável do
CLIPS que ele representa está gravado no banco de dados na Tabela 6. Isso possibilita que o JSP
gere dinamicamente as variáveis de entrada para o sistema especialista, isto para um número não
fixo de variáveis.
58
Após recuperação das informações de acesso do aluno do banco de dados e a organização
das mesmas em estruturas de dados adequadas, para poder-se acessar o JCLIPS foi então
desenvolvido um programa externo que recupera as informações do banco e executa o sistema
especialista. O processamento da IA, então, é dado através da leitura da saída de um programa
externo que processa as regras. O programa externo é iniciado através de uma chamada de sistema
que tem como argumento o desempenho do aluno. O JSP então permanece lendo tudo que o
programa externo retorna e espera até o final de sua execução.
O programa externo (também feito em Java e que acopla o JCLIPS) recupera o desempenho
do aluno, o categoriza nas quatro classes de desempenho (fraco, regular, bom, ótimo) e produz os
fatos no JCLIPS. Para produzir estes fatos, este programa também busca no PostgreSQL as
informações do aluno necessárias ao JCLIPS (áreas que o aluno já visitou, por exemplo). Depois de
todos os valores serem atribuídos às variáveis de entrada, o JCLIPS é rodado e devolve as variáveis
de saída, através da saída padrão do sistema, que está sendo armazenado em um buffer pelo JSP e
posteriormente são enviadas ao filme em Macromedia Flash.
Tem-se então os seguintes passos do aluno dentro do sistema, explicado através da
seqüência de telas a seguir. No início do sistema, assim que o aluno acessa o sistema tutor, seus
dados de nome de usuário, ou login, e senha são requisitados em uma tela de autenticação (Figura
28). Caso ele insira dados não condizentes com os que constam no banco de dados, ou deixe um dos
campos em branco, o sistema mostra uma mensagem de erro.
59
Figura 28. Tela de login e senha
Após a verificação de login e senha do aluno, seus outros dados existentes no banco (Tabela
4), como o nome completo e a informação de que é a primeira vez que o aluno acessa o sistema, são
adicionados a uma sessão JSP. Uma sessão mantém variáveis comuns a todos os scripts JSP
guardadas em um objeto, sendo estas informações perenes e somente perdidas no momento em que
o usuário fecha seu navegador.
Caso seja a primeira vez que o usuário acessa o sistema o agente exibe um diálogo sobre as
funcionalidades do mesmo (Figura 29). Logo após exibir a explicação o sistema grava no banco a
informação de que o aluno já acessou e então o aluno entra no sistema tutor em si e pode navegar
pelos itens e sub-itens do sistema (Figura 35). A partir deste momento o agente fica monitorando os
passos do aluno dentro do sistema, a fim de gravar sua interações.
Quando o aluno escolhe o item auto-avaliação, o sistema tutor gera um conjunto de
perguntas aleatórias correspondentes ao tópico atual (Figura 31). O aluno, ao clicar em avaliar, faz
com que o sistema contabilize os acertos e informe o agente do valor destes acertos, o que dispara o
acesso ao JCLIPS para obtenção da feição a ser exibida pelo agente (Figura 32). Caso o aluno tenha
deixado de preencher alguma questão o sistema a contabilizará como um erro.
60
Figura 29. Agente explicando o ambiente
61
Figura 30. Itens do STI
Figura 31. Auto-avaliação
62
Figura 32. Agente interagindo com o aluno
3.6 Criação das Regras
Durante a modelagem e implementação do agente, a árvore de decisões ainda não havia sido
inteiramente definida, o que implicou em mudanças no comportamento do agente e das interações
no ambiente.
Inicialmente, para organizar o funcionamento das regras do sistema especialista, fez-se
necessário ter ao alcance algumas informações referentes a como o conteúdo está organizado e
como seria tratado pela ótica do pedagogo. Sendo assim, algumas planilhas foram fornecidas para
os conteudistas a fim de que eles organizassem estes aspectos. Estas planilhas estão no ANEXO IV
e mostram todas as hierarquias de acesso possíveis e suas respectivas estratégias, onde o conteudista
deve preencher colocando a estratégia de resposta correspondente. Uma estratégia é o próximo item
do conteúdo do STI que o agente indicará para o aluno a visualizar.
Respondidos estes questionários implementou-se então, no que se refere ao desempenho do
aluno, cinco classes ou níveis de desempenho possíveis na auto-avaliação. Posteriormente essas
63
classes foram alteradas para somente quatro: fraco, regular, bom e ótimo. As regras levam em
conta, então, os critérios demonstrados na Tabela 9.
Tabela 9. Desempenho do aluno
Desempenho Comportamento Face
Comportamento Físico Comportamento Verbal (Frases)
Fraco (< 5) Triste Imóvel - Que tal estudar mais? - Você não estudou como eu te orientei! - Leia melhor o conteúdo para seu desempenho melhorar!
Regular (>= 5 e < 7) Balançando Inspira - Sei que você está se esforçando, que tal estudar um pouco mais? - Se você se concentrar melhor irá tirar melhores notas! - Você precisa estudar mais!
Bom (> 7 e < 9) Sorri Imóvel - Você está chegando lá, estude mais um pouco! - Você precisa ter só mais um pouquinho de concentração! - Se você estudar mais um pouquinho ficará ótimo.
Ótimo (> 9) Sorri Pulando - Parabéns, seu desempenho está excelente! - Muito bom!
Com a organização hierarquia dos conteúdos e dos tempos mínimos de acesso, as árvores de
decisão foram implementadas e validadas. As regras de produção foram criadas e validadas no
Expert Sinta e implementadas no CLIPS. As árvores podem ser vistas na Figura 33.
64
Figura 33. Árvore de decisões do sistema especialista
O Expert Sinta (LIA/UFC, 1996) é o sistema encarregado de transformar esta árvore de
decisão em regras, para assim validá-la. A árvore, que é vista graficamente na Figura 33 e em forma
de regras do sistema especialista na Figura 34, está esboçada de uma forma generalizada, ainda não
levando em conta qual sub-item o aluno está acessando. Fica encarregada aos conteudistas a missão
de idealizar e montar estas árvores de decisão até o final do projeto.
Estas regras também não incluem muitas feições diferentes para cada resultado, porém
futuramente ao longo da conclusão do projeto, mais feições serão adicionadas. A exemplo do que
acontece com as várias mensagens o sistema escolherá aleatoriamente um resultado das feições
cadastradas para cada resultado.
65
Entende-se também que, caso o aluno não tenha ficado tempo suficiente em cada conteúdo,
isso não é considerado um acesso. Este controle, porém, é feito pelo Java, antes mesmo de as
variáveis serem colocadas no CLIPS.
VARIÁVEIS acessou_conteudo Tipo: univalorada acessou_correlacao Tipo: univalorada acessou_historia Tipo: univalorada acessou_maonamassa Tipo: univalorada corpo Valores: imovel pulando inspira Tipo: univalorada desempenho Valores: regular ótimo fraco bom Tipo: univalorada estrategia Valores: sugerir_correlacao sugerir_historia sugerir_maonamassa sugerir_conteudo Tipo: univalorada mensagem Valores: regular otimo fraco bom Tipo: univalorada rosto Valores: balancando sorri triste Tipo: univalorada OBJETIVOS rosto estrategia mensagem corpo REGRAS Regra 1 SE desempenho = fraco E acessou_conteudo = Sim E acessou_correlacao = Sim E acessou_historia = Sim E acessou_maonamassa = Sim ENTÃO estrategia = sugerir_conteudo CNF 100% rosto = triste CNF 100% corpo = imovel CNF 100% mensagem = fraco CNF 100% Regra 2 SE desempenho = fraco E acessou_conteudo = Sim
66
E acessou_correlacao = Sim E acessou_maonamassa = Sim E acessou_historia = Não ENTÃO estrategia = sugerir_historia CNF 100% rosto = triste CNF 100% corpo = imovel CNF 100% mensagem = fraco CNF 100% Regra 3 SE desempenho = fraco E acessou_conteudo = Sim E acessou_correlacao = Sim E acessou_maonamassa = Não ENTÃO estrategia = sugerir_maonamassa CNF 100% rosto = triste CNF 100% corpo = imovel CNF 100% mensagem = fraco CNF 100% Regra 4 SE desempenho = fraco E acessou_conteudo = Sim E acessou_correlacao = Não ENTÃO estrategia = sugerir_correlacao CNF 100% rosto = triste CNF 100% corpo = imovel CNF 100% mensagem = fraco CNF 100% Regra 5 SE desempenho = fraco E acessou_conteudo = Não ENTÃO estrategia = sugerir_conteudo CNF 100% rosto = triste CNF 100% corpo = imovel CNF 100% mensagem = fraco CNF 100% Regra 6 SE desempenho = regular E acessou_conteudo = Sim E acessou_correlacao = Sim E acessou_historia = Sim E acessou_maonamassa = Sim ENTÃO estrategia = sugerir_conteudo CNF 100% rosto = balancando CNF 100% corpo = inspira CNF 100% mensagem = regular CNF 100% Regra 7 SE desempenho = regular E acessou_conteudo = Sim E acessou_correlacao = Sim E acessou_maonamassa = Sim E acessou_historia = Não ENTÃO estrategia = sugerir_historia CNF 100% rosto = balancando CNF 100% corpo = inspira CNF 100% mensagem = regular CNF 100% Regra 8 SE desempenho = regular E acessou_conteudo = Sim E acessou_correlacao = Sim E acessou_maonamassa = Não ENTÃO estrategia = sugerir_maonamassa CNF 100% rosto = balancando CNF 100% corpo = inspira CNF 100% mensagem = regular CNF 100% Regra 9 SE desempenho = regular E acessou_conteudo = Sim E acessou_correlacao = Não ENTÃO estrategia = sugerir_correlacao CNF 100% rosto = balancando CNF 100% corpo = inspira CNF 100% mensagem = regular CNF 100% Regra 10 SE desempenho = regular E acessou_conteudo = Não ENTÃO estrategia = sugerir_conteudo CNF 100% rosto = balancando CNF 100% corpo = inspira CNF 100% mensagem = regular CNF 100% Regra 11
67
SE desempenho = bom ENTÃO estrategia = sugerir_conteudo CNF 100% rosto = sorri CNF 100% corpo = imovel CNF 100% mensagem = bom CNF 100% Regra 12 SE desempenho = ótimo ENTÃO estrategia = sugerir_conteudo CNF 100% rosto = sorri CNF 100% corpo = pulando CNF 100% mensagem = otimo CNF 100%
Figura 34. Regras do sistema especialista
Para a implementação das regras no CLIPS seguiram-se as premissas descritas a seguir. No
seu formato mais básico, o CLIPS opera mantendo uma lista de fatos e um conjunto de regras que
lidam com estes fatos. Um fato é uma variável com um valor, um pedaço de informação como “(cor
azul)” ou “(acessou_conteudo sim)”, descrito nesta notação de parênteses comum ao LISP. Fatos
são criados através do comando “assert”, como, por exemplo, “(assert (cor azul))” (RILEY, 2006).
Para se obter algum resultado do CLIPS, deve-se definir regras, que, em geral, são expressas
na forma “se algo for verdade então tome tal atitude”. Três regras são exemplificadas no código da
Figura 35 (RILEY, 2006).
(defrule qual_mensagem (desempenho otimo) => (assert (mensagem parabens))) (defrule qual_estrategia (desempenho otimo) (acessou_conteudo nao) => (assert (estrategia acessar_conteudo))) (defrule qual_mensagem (or (desempenho fraco) (desempenho regular)) => (assert (mensagem ler_onteudo)))
Figura 35. Regras do sistema especialista
A primeira regra, a mais simples, consiste de três partes. A primeira, logo na primeira linha
da Figura 35 simplesmente dá um nome único a regra. Já na segunda linha tem-se a segunda parte,
correspondente ao “se” da sentença: “se o desempenho do aluno foi ótimo”. Na quarta e última
linha desta regra tem-se a última parte, a da ação a ser tomada, e a conclusão da sentença: “então a
mensagem é de parabéns”. Conclui-se então que, no caso do primeiro fato ser verdade, ele cria um
segundo fato (RILEY, 2006).
Para termos o operador lógico “e”, basta adicionarmos mais um fato na segunda parte da
regra, como visto na segunda regra da Figura 35. Já para adicionarmos um operador lógico “ou”,
68
basta utilizar o operador “or” antes dos dois fatos a serem comparados. O operador, na linguagem
do CLIPS, vem antes dos operandos, o que caracteriza uma notação chamada “notação prefix” ou
“notação polonesa”. Por exemplo, para se somar quatro e três em uma notação de linguagens
comuns (“notação infix”), normalmente escrever-se-ia “4 + 3”, porém no CLIPS deve-se utilizar
“(+ 4 3)” (RILEY, 2006). As regras de produção deste projeto encontram-se no ANEXO V.
3.7 Diagramas
As funcionalidades descritas anteriormente podem ser visualizadas organizadas em módulos
do sistema, no diagrama UML (Unified Modeling Language) mostrado na Figura 36. Já uma
descrição mais detalhada dessa comunicação e atuação do agente entre o STI e o servidor pode ser
vista no diagrama de seqüência da Figura 37. O banco de dados, com as tabelas e suas relações,
pode ser visto no diagrama da Figura 38.
cd Class Model
STI
+ alunoInterage()+ obtemConteudo()
Agente
- historicoAluno: char
+ calculaDesempenho()+ executarFeicao()+ informaInteracao()+ verificaAcao()
BancodeDados
+ gravaInteracao() : void+ obtemConteudo() : void
JCLIPS
+ infereRegras() : void
Figura 36. Diagrama contendo os módulos do sistema
69
sd Interaction
Bernardo :Agente Serv idor:BancodeDados
Aluno Interface :STI
Serv idor :JCLIPS
loop Aluno interagindo com conteúdos do STI
alt Aluno executou auto-av aliação
alunoInterage(tipoInteracao)
informaInteracao(idAcao)
verificaAcao(idAcao)
[acao != autoavaliacao]:gravaInteracao(idAluno, idAcao, idSubTopico)
obtemConteudo(idConteudo)
arquivoHTML:= obtemConteudo(idConteudo)
[acao==autoavaliacao]:calculaDesempenho()
gravaInteracao(idAluno, desempenho)
infereRegras(idAluno, historicoInteracoes, desempenho)
resposta(feicao, textoEstrategia)executarFeicao(texto)
Figura 37. Diagrama de seqüência
70
cd SQL
Alunos
*PK «column» idAluno: «column» Login: «column» Senha: «column» Nome: «column» PrimeiroLogin:
+ «PK» PK_Alunos()
Acessos
*PK «column» idAcesso: FK «column» idAluno: FK «column» idTopico: FK «column» idItem: «column» Data: «column» Tempo:
+ «FK» FK_Acessos_Alunos()+ «FK» FK_Acessos_Itens()+ «FK» FK_Acessos_Topicos()+ «PK» PK_Acessos()
Itens
*pfK «column» idItem: FK «column» idTopico: «column» NumeroItem: «column» TempoMin: «column» ClipsRegra:
+ «FK» FK_Itens_Topicos()+ «PK» PK_Itens()
Questoes
*PK «column» idQuestao: FK «column» idTopico: «column» Enunciado: «column» Opcao1: «column» Opcao2: «column» Opcao3: «column» Opcao4: «column» Figura: «column» Correta:
+ «FK» FK_Questoes_Topicos()+ «PK» PK_Questoes()
Topicos
*PK «column» idTopico: «column» Nome:
+ «PK» PK_Topicos()
0..*
+FK_Questoes_Topicos
1 +PK_Topicos
0..*
+FK_Itens_Topicos
1+PK_Topicos
0..* +FK_Acessos_Topicos 1
+PK_Topicos
0..*
+FK_Acessos_Itens
1
+PK_Itens
0..*
+FK_Acessos_Alunos
1+PK_Alunos
Figura 38. Diagrama do banco de dados
4 CONCLUSÕES
O objetivo geral deste TCC de desenvolver um sistema de comunicação e acoplamento de
um STI com a ferramenta JCLIPS, possibilitando a criação de um agente pedagógico inteligente, foi
realizado com sucesso.
A proposta de se desenvolver um agente pedagógico levou ao estudo e análise dos modelos
conceituais para o STI de neurofisiologia feitos pela equipe do projeto, o que possibilitou a criação
de uma modelagem de como essa comunicação se daria baseando-se no andamento de construção
em que o STI se encontrava.
Existe um grande grau de desafio quando se trata de integração de tecnologias, devido a
diferença nos tipos de dados suportados por cada programa e pela arquitetura diferenciada de
trabalho de cada uma das tecnologias. Porém, apesar do fato de que a arquitetura já identificava
todos os pontos de observação e atuação do agente, ou seja, as variáveis do STI que o agente fará
uso, todo o processo de acoplamento de comunicação dentre as diversas tecnologias tiveram seus
percalços.
Com o uso de um sistema especialista para a inteligência do agente, a identificação da
melhor implementação deste tipo de sistema trouxe dúvidas na escolha da tecnologia a ser utilizada,
porém a escolha do JCLIPS foi natural, à medida que ele correspondia com os vários requisitos de
escolha trazidos a tona, sendo uma das poucas tecnologias livres para desenvolvimento em Java e
com seu uso baseado no sólido CLIPS.
Iniciada a implementação, alguns problemas tiveram de ser contornados. Os principais
foram a não existência de um STI funcional para acoplamento e a não existência das regras
completas para os assuntos. Com isso foram desenvolvidas algumas regras para um STI menor que
funcionou como um protótipo. As regras criadas para o protótipo, apesar de restritas pelos
problemas encontrados, suprem as necessidades de teste da arquitetura, além de mostrar as
intenções educacionais do agente.
O Expert Sinta se mostrou eficiente na validação destas regras de produção,
disponibilizando uma interface que monta uma espécie de guia, mostrando todas as regras e
facilitando acesso a elas e aos resultados que elas geram. As regras de produção, porém, na
linguagem do CLIPS, são completamente diferentes em sua sintaxe escrita. Talvez o
72
desenvolvimento de alguma ferramenta de exportação direta das regras desenvolvidas no Expert
Sinta para a linguagem CLIPS fosse relevante para ambientes corporativos que lidam fortemente
com este tipo de tecnologia.
O teste dos elementos de comunicação e do agente foi satisfatório, e se deu junto com a
equipe de desenvolvimento do agente. Um dos elementos ainda não testados do agente foi a sua
utilização na plataforma Linux, sistema operacional no qual o servidor do projeto se encontra,
devido à falta de um servidor com estas características para testes.
Para o futuro, a arquitetura deverá ser adequada ao STI final e ao conteúdo completo que
será desenvolvido pela equipe de desenvolvedores e conteudistas do projeto. Também Poderão ser
implementadas outras funções e outros aspectos de interação do agente com o aluno, aumentando a
naturalidade de sua existência como companheiro de aprendizagem. Como projeto futuro também
se deve expandir a abrangência das regras, fazendo-as levar em conta também os sub-itens.
Durante o desenvolvimento desta aplicação a existência de outras ferramentas de sistema
especialista e processamento de regras de produção que funcionam em Java, como o JEOPS (Java
Embedded Object Production System) (FIGUEIRA FILHO, 2001) e o Drools, atualmente chamado
JBOSS Rules (RED HAT MIDDLEWARE, 2006), foi constatada. Um estudo de suas
funcionalidades e uma comparação dessas ferramentas com o JCLIPS seria um ponto de partida
para novos projetos.
Foram também submetidos artigos sobre este TCC para eventos regionais e nacionais, sendo
que a proposta foi aceita até o momento nos eventos: WIM (Workshop de Informática Médica)
2006, SulComp 2006, CBIS (Congresso Brasileiro de Informática em Saúde) 2006, SBIE (Simpósio
Brasileiro de Informática na Educação) 2006, SIMS (Simpósio de Informática e Mostra de Software
Acadêmico) 2006, conforme ANEXO III.
REFERÊNCIAS BIBLIOGRÁFICAS
ABOWD, G.; ENGESLMA, J.; GUADAGNO L. e OKON, O. Architectural analysis of object request brokers. Object Magazine, New York, n. 98, p. 44-51, mar. 1996.
AHMED, K. S.; KASSIM, A. A.; RANGANATH, S. Pundit: an animated pedagogical agent in web-based intelligent learning environment for digital system (WILEDS). In: INTERNATIONAL CONFERENCE ON LEARNING AND TEACHING ON-LINE: PRACTICES, CHALLENGES AND PROSPECTS, 1., 2001, Guangzhou. Proceedings… Bangkok: UNESCO (United Nations Educational, Scientific and Cultural Organization), 2001.
ALVES, Andréa C. O. Proposta de um modelo para a implementação de um ambiente inteligente para o ensino de informática médica. 2002. 114 f. Dissertação (Mestrado em Engenharia de Produção)–Programa de Pós-Graduação em Engenharia de Produção, Universidade Federal de Santa Catarina, Florianópolis, 2002.
APACHE SOFTWARE FOUNDATION. The Apache Jakarta project. 2005. Disponível em: <http://jakarta.apache.org/>. Acesso em: 22 out. 2006.
BIGUS, Joseph P.; BIGUS, J. Constructing intelligent agents using JAVA. 2. ed. New York: John Wiley & Sons, 2001. 432 p.
CHAIBEN, Hamilton. Hipermídia na educação. Curitiba: Universidade Federal do Paraná, 1999.
COSTA, M. T. C. Uma arquitetura baseada em agentes para suporte ao ensino à distância. 1999. Tese (Doutorado em Engenharia de Produção)–Programa de Pós-Graduação em Engenharia de Produção, Universidade Federal de Santa Catarina, Florianópolis, 1999.
CRIGHTON, D. Adding a truth maintenance system to ERA, the Electronic Referee Assistant, to allow backtracking. 2005. 83 f. Dissertação (Mestrado em Ciência da Computação)–Postgraduate Degree Program in Computer Science, University of Edinburgh, Edinburgh, 2005.
DOWLING, C. Intelligent pedagogical agents in online learning environments. ICEUT: INTERNATIONAL CONFERENCE ON EDUCATIONAL USES OF INFORMATION AND COMMUNICATION TEHCNOLOGIES, 16., 2000, Pequim. Proceedings… Laxenburg: IFIP (International Federation for Information Processing), 2000.
EBERSPACHER, H. F.; KAESTNER, C. A. A. A arquitetura de um sistema de autoria para a construção de tutores inteligentes hipermídia e seu posicionamento na informática educativa. In: CONGRESSO IBERO-AMERICANO DE EDUCAÇÃO, 4., 1998, Brasília. Anais... [S.l.: s.n.], 1998.
FERNANDES, Anita M. R. Sistema especialista difuso aplicado ao processo de análise química qualitativa de amostras de minerais. 1996. 146 f. Dissertação (Mestrado em Ciência da Computação)– Programa de Pós-Graduação em Ciência da Computação, Universidade Federal de Santa Catarina, Florianópolis, 1996.
FERNANDES, A. M. R.; DETERS, J. I.; FERNANDES, L. S.; OLDONI, A. Desenvolvimento de agente pedagógico utilizando a ferramenta JCLIPS. In: WORKSHOP DE INFORMÁTICA
74
MÉDICA¨, 6., 2006, Vila Velha. Anais do V Simposio Brasileiro de Qualidade de Software, [S.l.: s.n.], 2006.
FIGUEIRA FILHO, Carlos. JEOPS: The Java embedded object production system. 2001. Disponível em: <http://www.di.ufpe.br/~jeops/>. Acesso em: 13 nov. 2006.
FINEP. Financiadora de estudos e projetos: A empresa. 2006. Disponível em: <http://www.finep.gov.br/o_que_e_a_finep/a_empresa.asp?codSessaoOqueeFINEP=2>. Acesso em: 8 jun. 2006.
FONER, L. What is an Agent, Anyway? A Sociological Case Study. Boston: MIT Media Lab, 1993. 40 p. (Relatório Técnico).
FRANKLIN S.; GRAESSER, A. Is it an Agent, or just a Program?: A Taxonomy for Autonomous Agents. In: INTERNATIONAL WORKSHOP ON AGENT THEORIES, ARCHITECTURES AND LANGUAGES, 3., 1996, Budapest. Proceedings… New York: Springer-Verlag, 1996.
FREEDMAN, Reva. What is an Intelligent Tutoring System? Intelligence, [S.l.], v. 11, n. 3, p. 15-16, 2000.
FREE SOFTWARE FOUNDATION. The GNU operating system. 2006a. Disponível em: <http://www.gnu.org/>. Acesso em: 8 jun. 2006.
FREE SOFTWARE FOUNDATION. Welcome to GPLv3. 2006b. Disponível em: <http://gplv3.fsf.org/>. Acesso em: 8 jun. 2006.
GAMBOA, H.; FRED, A. Designing Intelligent Tutoring Systems: a Bayesian approach. In: INTERNATIONAL CONFERENCE ON ENTERPRISE INFORMATION SYSTEMS, 3., 2001, Setúbal. Proceedings…[S.l.: s.n.], 2001.
GIORDANO, M. CLIPS interface and sample projects. 2003. Disponível em: <http://clipsinterface.sourceforge.net/WebCLIPS/wchome.htm>. Acesso em: 9 abr. 2001.
GIRAFFA, L. M. M.; GOULART, R. R. V. Arquiteturas de sistemas tutores inteligentes. Porto Alegre: Pontifícia Universidade Católica do Rio Grande do Sul, 2001. 32 p. (Relatório Técnico).
GIRAFFA, L. M. M.; VICCARI, R. M. ITS built as game like fashion using pedagogical agents. SEMANA ACADÊMICA DO PPGCC (PROGRAMA DE PÓS-GRADUAÇÃO EM CIÊNCIA DA COMPUTAÇÃO) DA UFRG, 3., 1998, Porto Alegre. Anais... [S.l.: s.n.], 1998.
GREGIO, B. M. A. A informática na educação: as representações sociais e o grande desafio do professor frente ao novo paradigma educacional. Revista Colabor@, Santos, v. 2, n. 6, mar. 2004.
JESS. JESS: the expert system shell for the Java platform. 2006. Disponível em: <http://www.jessrules.com/>. Acesso em: 7 jun. 2006.
JOHNSON, W. L. Pedagogical Agents. In: ICCE: INTERNATIONAL CONFERENCE ON COMPUTERS IN EDUCATION, 6., 1998, Beijing. Proceedings… Beijing: China Higher Education Press, 1998.
75
KOMOSINSKI, L. J. Um novo significado para a educação tecnológica fundamentado na informática como artefato mediador da aprendizagem. 2000. 146 f. Tese (Doutorado em Engenharia de Produção)–Programa de Pós-graduação em Engenharia de Produção, Universidade Federal de Santa Catarina, Florianópolis, 2000.
LANGE, D. B. Mobile objects and mobile agents: the future of distributed computing? In: EUROPEAN CONFERENCE ON OBJECT-ORIENTED PROGRAMMING, 12., 1998, Brussels. Proceedings… Berlin: Springer-Verlag, 1998.
LESTER, J. C.; STONE, B. A. Increasing believability in animated pedagogical agents. In: INTERNATIONAL CONFERENCE ON AUTONOMOUS AGENTS, 1., 1997, Marina del Rey. Proceedings… New York: ACM Press, 1997.
LESTER, J. C.; VOERMAN, J. L.; TOWNS, S. G.; CALLAWAY, C. B. Cosmo: a life-like animated pedagogical agent with deictic believability. In: INTERNATIONAL JOINT CONFERENCE ON ARTIFICIAL INTELLIGENCE, 15., 1997, Nagoya. Proceedings… [S.l.: s.n.], 1997.
LIA/UFC. Expert Sinta Shell: uma ferramenta visual para construção de sistemas especialistas. 1996. Disponivel em: <http://www.lia.ufc.br/~bezerra/exsinta/exsintashell.htm>. Acesso em: 12 jun. 2006.
LOINAZ, M. U. Sistemas inteligentes en el ámbito de la educación. Revista Iberoamericana de Inteligencia Artificial, Valencia, n. 12, p. 5-12, 2001.
MACROMEDIA. Using Flash. 2004a. Disponivel em: <http://download.macromedia.com/pub/ documentation/en/flash/mx2004/fl_usingas_in_flash.pdf>. Acesso em: 19 jun. 2006.
MACROMEDIA. ActionScript language reference. 2004b. Disponivel em: <http://download.macromedia.com/pub/documentation/en/flash/mx2004/ fl_actionscript_reference.pdf>. Acesso em: 19 jun. 2006.
MAIA , W. U. L. A. Sistema integrado de operação e diagnóstico de falhas para sistemas de energia elétrica – SODF. 1998. Dissertação (Mestre em Engenharia de Produção)–Programa de Pós-Graduação em Engenharia de Produção, Universidade Federal de Santa Catarina, Florianópolis, 1998.
MENESES, J. M. A informática e o ensino de morfologia da língua portuguesa na 1ª série do ensino médio: um estudo de caso. 2000. 108 f. Dissertação (Mestrado em Engenharia de Produção) – Programa de Pós-Graduação em Engenharia de Produção, Universidade Federal De Santa Catarina, Florianópolis, 2000.
MENKEN, M. JCLIPS: Clips for Java. 2005. Disponível em: <http://www.cs.vu.nl/~mrmenken/ jclips/>. Acesso em: 7 jun. 2006.
MICROSOFT CORPORATION. Microsoft Internet Explorer. 2006. Disponível em: <http://www.microsoft.com/brasil/windows/ie/default.mspx>. Acesso em: 8 nov. 2006.
MINISTÉRIO DA EDUCAÇÃO. PROINESP: Projeto de Informática na Educação Especial. 2004. Disponível em: <http://portal.mec.gov.br/seesp/index.php?option=content&task=view &id=74&Itemid=203>. Acesso em: 7 jun. 2006.
76
MORAES, M. C. Informática educativa no Brasil: uma história vivida, algumas lições aprendidas. Revista Brasileira de Informática na Educação, Florianópolis, n. 1, p. 19-44, set. 1997.
MOURA, M. F.; CRUZ, S. A. B. Estudo de expert system shells para o ambiente de diagnose remota. Campinas: Embrapa, 2001. 22 p. (Relatório Técnico).
MOZILLA FOUNDATION. Firefox 2. 2006. Disponível em: <http://www.mozilla.org.br/>. Acesso em: 8 nov. 2006.
NOVELL. OpenSUSE: Welcome to OpenSUSE. 2005. Disponível em: <http://en.opensuse.org/>. Acesso em: 19 jun. 2006.
NUNES, Maria A. S. N.; FRAGA, Luciane; DIHL, Leandro L.; OLIVEIRA, Lisiane; WOSZEZENKI, Cristiane R.; FRANCISCO, Deise J.; MACHADO, Glaucio J.C.; NOGUEIRA, Carmen R. D.; NOTARGIACOMO, Maria da G. Animated pedagogical agent in a learning environment. In: SEC: OPEN IFIP-GI-CONFERENCE ON SOCIAL, ETHICAL AND COGNITIVE ISSUES OF INFORMATICS AND ICT (INFORMATION AND COMMUNICATION TECHNOLOGIES), 3., 2002, Dortmund. Proceedings… Laxenburg: IFIP (International Federation for Information Processing), 2002.
NWANA, H. Software Agents: An Overview. Knowledge Engineering Review, v. 11, n. 3, p. 1-40, set. 1996.
PEREIRA, A. S.; GEYER, C. F. R. Um Agente para Seleção de Estratégias de Ensino em Ambientes Educacionais na Internet. RITA (Revista de Informática Teórica e Aplicada). Porto Alegre, v. 6, n. 2, p. 89-105, jul. 1999.
PGADMIN. Introduction . 2006. Disponível em: <http://www.pgadmin.org/index.php>. Acesso em: 30 out. 2006.
POSTGRESQL. About PostgreSQL. 2006. Disponível em: <http://www.postgresql.org/about/>. Acesso em: 6 jun. 2006.
POSTGRESQL. PostgreSQL JDBC driver. 2005. Disponível em: <http://jdbc.postgresql.org/>. Acesso em: 23 out. 2006.
RED HAT MIDDLEWARE. JBOSS Rules. 2006. Disponível em: <http://labs.jboss.com/portal/jbossrules/>. Acesso em: 13 nov. 2006.
REFSNES DATA. Browser Statistics. 2006a. Disponível em: <http://www.w3schools .com/browsers/browsers_stats.asp>. Acesso em: 13 jun. 2006.
REFSNES DATA. JavaScript Reference. 2006b. Disponível em: <http://www.w3schools.com/ jsref/default.asp>. Acesso em: 13 jun. 2006.
REFSNES DATA. HTML iframe tag . 2006c. Disponível em: <http://www.w3schools.com/ tags/tag_iframe.asp>. Acesso em: 30 out. 2006.
RICKEL, J.; JOHNSON, W. L. Steve: an animated pedagogical agent for procedural training in virtual environments. SIGART (Special Interest Group on Artificial Intell igence) Bulletin, New York, v. 8, n. 1-4, p. 16-21, 1997.
77
RILEY, G. CLIPS: a tool for building expert systems. 2005. Disponível em: <http://www.ghg.net/ clips/CLIPS.html>. Acesso em: 7 jun. 2006.
RILEY, G. What is CLIPS?. 2004. Disponível em: <http://www.ghg.net/clips/WhatIs CLIPS.html>. Acesso em: 8 jun. 2006.
RILEY, G. CLIPS reference manual: basic programming guide. 2006. Disponível em: <http:// www.ghg.net/clips/download/documentation/bpg.pdf>. Acesso em: 24 out. 2006.
RUSSELL, S.; NORVIG, P. Inteligência Artificial . 2. ed. Rio de Janeiro: Campus, 2004. 1040 p.
SANTOS, C. T.; DAHMER, A.; FROZZA, R.; GASPARY, L. P. Dóris: um agente de acompanhamento pedagógico em sistemas tutores inteligentes. In: SIMPÓSIO BRASILEIRO DE INFORMÁTICA NA EDUCAÇÃO, 12., 2001, Vitória. Anais... Vitória: UFES, 2001.
SAVARIS, S. V. A. M. Sistema Especialista para primeiros socorros para cães. 2002. 156 f. Dissertação (Mestrado em Ciência da Computação)–Programa de Pós-Graduação em Ciência da Computação, Universidade Federal de Santa Catarina, Florianópolis, 2002.
SELF, J. Computational mathetics: towards a science of learning systems design. 1995. Disponível em: <http://www.drakkar.co.uk/cm.htm>. Acesso em: 25 fev. 2006.
SHAW, E.; GANESHAN, P.; JOHNSON, W. L.; MILLAR, D. Building a case for agent-assisted learning as a catalyst for curriculum reform in medical education. In: WORLD CONFERENCE ON ARTIFICIAL INTELLIGENCE IN EDUCATION, 9., 1999, Le Mans. Anais… Amsterdam: IOS Press, 1999.
SILVA, A. P. C. Aplicações de sistemas tutores inteligentes na educação à distância: possibilidades e limites. In: SEMINÁRIO NACIONAL ABED (ASSOCIAÇÃO BRASILEIRA DE EDUCAÇÃO À DISTÂNCIA) DE EDUCAÇÃO À DISTÂNCIA, 4., 2006, Brasília. Anais... [S.l.: s.n.], 2006.
SPECTOR, L. Automatic generation of intelligent agent programs. IEEE Intelligent Systems, Washington, v. 12, n. 1, p. 3-4, 1997.
SUN. Java technology and web services. 2006a. Disponível em: <http://java.sun.com/web services/>. Acesso em: 31 maio. 2006.
SUN. Java technology. 2006b. Disponível em: <http://java.sun.com/>. Acesso em: 7 jun. 2006.
SUN. Java Server Pages technology. 2006c. Disponível em: <http://java.sun.com/products/jsp/ index.jsp>. Acesso em: 7 jun. 2006.
SUN. NetBeans software. 2006d. Disponível em: <http://www.netbeans.org/>. Acesso em: 22 out. 2006.
SUN. Using JavaServer Faces technology components. 2004. Disponível em: <http://developers.sun.com/prodtech/javatools/jscreator/reference/themes/jsf/index.html>. Acesso em: 7 jun. 2006.
TEIXEIRA, A. C.; BRANDÃO, E. J. R. Software educacional: o difícil começo. Renote (Revista Novas Tecnologias na Educação), Porto Alegre, v. 1, n, 1, p. 1-7, fev. 2003.
78
VALENTE, José Armando. Diferentes usos do computador na educação. In: VALENTE, José Armando (Org.). Computadores e conhecimento: repensando a educação. Campinas: UNICAMP 1993. p. 1- 28. (Capítulo I)
VALENTE, J. A.; ALMEIDA, F. J. Visão analítica da informática na educação no Brasil: a questão da formação do professor. Revista Brasileira de Informática na Educação, Florianópolis, n. 1, p. 45-60, set. 1997.
VILLAREAL, G. F. Agentes inteligentes en educación. Edutec (Revista Electrónica de Tecnología Educativa), Islas Baleares, n. 16, abr. 2003.
VICCARI, R.M.; GIRAFFA, L.M.M. Fundamentos dos sistemas tutores inteligentes. In: BARONE et al. (Org.) Sociedades artificiais: a nova fronteira da inteligência das máquinas. Porto Alegre: Bookman, 2003.
W3C. Extensible Markup Language (XML). 2006. Disponível em: <http://www.w3.org/XML/>. Acesso em: 31 maio. 2006.
WOOLDRIDGE, M.; JENNINGS, N. R. Intelligent Agents: Theory and Practice. Knowledge Engineering Review. Cambridge, v.10, n. 2, p. 115-152, 1995.
79
ANEXOS
I MODELAGEM DO BANCO DE DADOS DO PORTAL SAÚDE+EDUCAÇÃO
81
82
II MODELAGEM DO SISTEMA TUTOR INTELIGENTE
83
III ARTIGO S SUBMETIDOS E ACEITOS
84
IV PLANILHA PARA PREENCHIMENTO DE CONTEUDISTAS
85
Planilha para preenchimento de sua estratégia correspondente
Hierarquia de acesso Estratégia do agente Auto-avaliação direto Mão na Massa, depois Auto-avaliação Conteúdo, depois Auto-avaliação Correlação Clínica, depois Auto-avaliação História, depois Auto-avaliação Conteúdo, depois Mão na Massa, depois Auto-avaliação
Conteúdo, depois Correlação Clínica, depois Auto-avaliação
Conteúdo, depois História, depois Auto-avaliação Conteúdo, depois Mão na Massa, depois História, depois Auto-avaliação
Conteúdo, depois Mão na Massa, depois Correlação clínica, depois Auto-avaliação
...
86
V REGRAS DE PRODUÇÃO
87
(defrule MAIN::R1 (desempenho fraco) (acessou_conteudo sim) (acessou_correlacao sim) (acessou_historia sim) (acessou_maonamassa sim) => (printout t "&estrategia=sugerir_conteudo&") (printout t "rosto=triste&") (printout t "corpo=imovel&") (printout t "mensagem=fraco&") ) (defrule MAIN::R2 (desempenho fraco) (acessou_conteudo sim) (acessou_correlacao sim) (acessou_historia nao) (acessou_maonamassa sim) => (printout t "&estrategia=sugerir_historia&") (printout t "rosto=triste&") (printout t "corpo=imovel&") (printout t "mensagem=fraco&") ) (defrule MAIN::R3 (desempenho fraco) (acessou_conteudo sim) (acessou_correlacao sim) (acessou_maonamassa nao) => (printout t "&estrategia=sugerir_maonamassa&") (printout t "rosto=triste&") (printout t "corpo=imovel&") (printout t "mensagem=fraco&") ) (defrule MAIN::R4 (desempenho fraco) (acessou_conteudo sim) (acessou_correlacao nao) => (printout t "&estrategia=sugerir_correlacao&") (printout t "rosto=triste&") (printout t "corpo=imovel&") (printout t "mensagem=fraco&") ) (defrule MAIN::R5 (desempenho fraco) (acessou_conteudo nao) => (printout t "&estrategia=sugerir_conteudo&") (printout t "rosto=triste&") (printout t "corpo=imovel&") (printout t "mensagem=fraco") )
88
(defrule MAIN::R6 (desempenho regular) (acessou_conteudo sim) (acessou_correlacao sim) (acessou_historia sim) (acessou_maonamassa sim) => (printout t "&estrategia=sugerir_conteudo&") (printout t "rosto=balancando&") (printout t "corpo=inspira&") (printout t "mensagem=regular") ) (defrule MAIN::R7 (desempenho regular) (acessou_conteudo sim) (acessou_correlacao sim) (acessou_historia nao) (acessou_maonamassa sim) => (printout t "&estrategia=sugerir_historia&") (printout t "rosto=balancando&") (printout t "corpo=inspira&") (printout t "mensagem=regular") ) (defrule MAIN::R8 (desempenho regular) (acessou_conteudo sim) (acessou_correlacao sim) (acessou_maonamassa nao) => (printout t "&estrategia=sugerir_maonamassa&") (printout t "rosto=balancando&") (printout t "corpo=inspira&") (printout t "mensagem=regular") ) (defrule MAIN::R9 (desempenho regular) (acessou_conteudo sim) (acessou_correlacao nao) => (printout t "&estrategia=sugerir_correlacao&") (printout t "rosto=balancando&") (printout t "corpo=inspira&") (printout t "mensagem=regular") ) (defrule MAIN::R10 (desempenho regular) (acessou_conteudo nao) => (printout t "&estrategia=sugerir_conteudo&") (printout t "rosto=balancando&") (printout t "corpo=inspira&") (printout t "mensagem=regular") ) (defrule MAIN::R11
89
(desempenho bom) => (printout t "&estrategia=sugerir_conteudo&") (printout t "rosto=sorri&") (printout t "corpo=imovel&") (printout t "mensagem=bom") ) (defrule MAIN::R12 (desempenho otimo) => (printout t "&estrategia=sugerir_conteudo&") (printout t "rosto=sorri&") (printout t "corpo=pulando&") (printout t "mensagem=otimo") )