universidade do vale do itajaÍ centro de ciÊncias ...siaibib01.univali.br/pdf/jhony luiz de...
TRANSCRIPT
UNIVERSIDADE DO VALE DO ITAJAÍ
CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
ERUDIO: SISTEMA MULTIAGENTE PARA ASSISTÊNCIA
PERSONALIZADA AOS ALUNOS DO AVA EDUCLINE
por
Jhony Luiz de Almeida
Itajaí (SC), novembro de 2012
UNIVERSIDADE DO VALE DO ITAJAÍ
CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
ERUDIO: SISTEMA MULTIAGENTE PARA ASSISTÊNCIA
PERSONALIZADA AOS ALUNOS DO AVA EDUCLINE
Área de Inteligência Artificial
por
Jhony Luiz de Almeida
Relatório apresentado à Banca Examinadora do
Trabalho Técnico-científico de Conclusão do
Curso de Ciência da Computação para análise e
aprovação.
Orientador: Benjamin Grando Moreira, M.Eng.
Itajaí (SC), novembro de 2012
AGRADECIMENTOS
A meus pais Andréia Mendes de Almeida e David Luiz de Almeida, que sempre me
forneceram uma educação exemplar e me deram todo o apoio e amor que um filho pode
desejar.
Ao meu orientador, Professor e Mestre Benjamin Grando Moreira, que me auxiliou em
todas as etapas da elaboração deste trabalho, realizando importantes contribuições.
Ao Professor e Mestre Rafael de Santiago, que se dispôs a ajudar ativamente na
integração do sistema desenvolvido com o seu projeto de mestrado, a rede LOP2P.
Agradeço a toda minha equipe de trabalho da Assessoria de Informatização
Educacional, em especial ao assessor, meu amigo Cleverson Alves Paes, que me cedeu tempo
hábil para realização das etapas desenvolvimento e testes do projeto.
Agradeço também aos meus amigos Gabriel Schade Cardoso e João Guilherme
Harger, que me proporcionaram troca de conhecimentos e experiências na realização de
diversos trabalhos em equipe no decorrer do curso.
Por fim, ofereço agradecimentos especiais ao meu amigo Antuniey Moacir Teodoro,
por colaborar com sua habilidade e criatividade concebendo as ilustrações do sistema
desenvolvido.
“No meio da dificuldade encontra-se a oportunidade.”
Albert Einstein
RESUMO
ALMEIDA, Jhony Luiz de. Erudio: Sistema multiagente para assistência personalizada
aos alunos do AVA Educline. Itajaí, 2012. 72 f. Trabalho Técnico-científico 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í, 2012.
A Secretaria Municipal de Educação de Itajaí, visando incorporar novas tecnologias
educacionais na rede municipal de ensino, desenvolveu seu próprio ambiente virtual de
aprendizagem baseado na plataforma MOODLE, chamado Educline. Considerando que uma
das metas do Educline é despertar maior interesse dos alunos por sua aprendizagem,
complementando as aulas presenciais com conteúdos e atividades diferenciadas, foi proposta
a criação de um sistema multiagente para auxiliá-los neste processo. O objetivo da proposta
foi fornecer aos alunos um assistente pessoal capaz de apresentar sugestões de ajuda nos
conteúdos em que eles possuem dificuldade. Erudio, como foi batizado o sistema, foi
implementado em três camadas, sendo elas respectivamente processamento, apresentação e
comunicação. A parte de processamento corresponde diretamente ao sistema multiagente
propriamente dito, o qual foi escrito na linguagem Java, usando o framework JADE. Foi
criado um agente de interface que desempenha o papel do assistente, identificando os
conteúdos em que os alunos possuem dificuldade através da análise das respostas nos
questionários e sugerindo materiais educacionais relacionados e colegas aptos a oferecer
assistência por chat. Cada aluno conectado ao ambiente possui um agente assistente dedicado
a ele. A apresentação é composta por um bloco MOODLE, de forma que pode ser inserida em
qualquer ambiente baseado nesta plataforma, e tem como função permitir que o aluno
visualize as sugestões e interaja com seu agente assistente enviando ordens. Como o
MOODLE é baseado na linguagem PHP, foi necessária a criação da camada de comunicação,
que se utiliza de uma extensão do JADE, o WSIG, para prover acesso da apresentação aos
serviços dos agentes, por meio da tecnologia de web services. Após o término do
desenvolvimento, o Erudio foi implantado com sucesso no ambiente Educline, onde passou
por testes que objetivaram constatar o cumprimento de seus requisitos funcionais.
Palavras-chave: Sistema multiagente, Agente de interface, Ambiente virtual de
aprendizagem, MOODLE.
ABSTRACT
The City Department of Education of Itajai, in order to incorporate new educational
technologies in municipal schools, has developed its own virtual learning environment based
on MOODLE platform, called Educline. Considering that one of Educline’s main goals is to
awaken greater interest of students by complementing the classroom with alternative contents
and activities, it has been proposed the creation of a multi-agent system to assist them in this
process. The aim of the proposal was to give students a personal assistant that could help
through suggestions on contents they have difficulty. The system, dubbed Erudio, was
implemented in three layers, which are respectively processing, presentation and
communication. The processing component corresponds directly to the multi-agent system
itself, which was written in the Java language using the JADE framework. It has been created
an interface agent that plays the role of the assistant, identifying difficulties of the student by
analyzing his answers in the questionnaires, and suggesting educational resources and
colleagues that are able to help him by chatting. Each connected student in the environment
has an assistant agent dedicated to him. The presentation layer consists of a MOODLE block,
so that can be inserted into any environment based on this platform, and its function is to
allow the student to view the suggestions and interact with the assistant agent by sending
orders. As MOODLE is based on PHP, it was necessary to create the communication layer,
which uses an extension of JADE, the WSIG, to provide to the presentation an access to the
services of the agents, through web services technology. Upon completion of the development,
Erudio was successfully deployed in Educline, where it has been tested aiming to verify the
fulfillment of their functional requirements.
Keywords: Multiagent system, Interface agent, Virtual Learning Environment, MOODLE.
LISTA DE FIGURAS
Figura 1. Página de um curso MOODLE .............................................................................. 24
Figura 2. Agente de recomendação de tutores ....................................................................... 33
Figura 3. Configuração do monitoramento de fóruns no MOODLE ...................................... 34
Figura 4. Arquitetura do sistema multiagente Erudio ............................................................ 39
Figura 5. Casos de uso do sistema desenvolvido ................................................................... 41
Figura 6. Diagrama de sequência da solicitação de ajuda de outro aluno............................... 46
Figura 7. Diagrama de sequência da solicitação de ajuda de recursos ................................... 47
Figura 8. Diagrama ER do módulo de questões (simplificado) ............................................. 52
Figura 9. Diagrama ER do módulo de tags (simplificado) .................................................... 53
Figura 10. Diagrama ER das tabelas do Erudio..................................................................... 54
Figura 11. Telas de apresentação do bloco Assistente Erudio ............................................... 56
Figura 12. Janela de chat do bloco Assistente Erudio ........................................................... 57
Figura 13. Troca de mensagens na atualização da apresentação ............................................ 59
Figura 14. Caso de obtenção de desempenho bom em todos os conteúdos ............................ 60
Figura 15. Caso de obtenção de desempenho regular em um conteúdo ................................. 61
Figura 16. Caso de obtenção de desempenho baixo em um conteúdo.................................... 62
Figura 17. Mensagens trocadas entre agentes durante um pedido de ajuda ............................ 63
Figura 18. Mensagens trocadas entre agentes durante uma busca de recursos ....................... 64
Figura 19. Dados de processamento e consumo de memória sem usuários conectados .......... 65
Figura 20. Dados de processamento e consumo de memória com quarenta usuários ............. 66
LISTA DE QUADROS
Quadro 1. Exemplo de mensagem KQML ............................................................................ 28
Quadro 2. Comparação entre os frameworks estudados ........................................................ 31
Quadro 3. Classificações automáticas de questões realizadas pelo sistema ........................... 64
LISTA DE ABREVIATURAS E SIGLAS
ACL Agent Communication Language
AJAX Asynchronous JavaScript and XML
API Application Programming Interface
AVA Ambiente Virtual de Aprendizagem
BDI Belief-Desire-Intention
CAI Computer Assisted Instruction
EaD Educação à Distância
ER Entidade-Relacional
FIPA Foundation for Intelligent Physical Agents
GPL General Public License
HTML HyperText Markup Language
IDE Integrated Development Environment
JADE Java Agent Development Framework
JDBC Java Database Connectivity
JDK Java Development Kit
KQML Knowledge Query Manipulation Language
LMS Learning Management System
OO Orientado(a) a objetos
SCORM Sharable Content Object Reference Model
SMA Sistema Multiagente
SOAP Simple Object Access Protocol
SRI Sistema de Recuperação de Informação
SQL Structured Query Language
TTC Trabalho Técnico-científico de Conclusão de Curso
UFSC Universidade Federal de Santa Catarina
UML Unified Modeling Language
UNIVALI Universidade do Vale do Itajaí
WSDL Web Services Description Language
WSIG JADE Web Services Integration Gateway
XML Extensible Markup Language
SUMÁRIO
1. INTRODUÇÃO .......................................................................................... 12
1.1 PROBLEMATIZAÇÃO .......................................................................... 14
1.1.1 Formulação do Problema ..................................................................... 14
1.1.2 Solução Proposta .................................................................................. 14
1.2 OBJETIVOS ............................................................................................. 15
1.2.1 Objetivo Geral ...................................................................................... 15
1.2.2 Objetivos Específicos ............................................................................ 15
1.3 METODOLOGIA .................................................................................... 15
1.4 ESTRUTURA DO TRABALHO ............................................................. 16
2. FUNDAMENTAÇÃO TEÓRICA ............................................................. 18
2.1 EDUCLINE .............................................................................................. 18
2.2 AMBIENTES VIRTUAIS DE APRENDIZAGEM ................................ 19
2.2.1 Metodologias pedagógicas em AVA .................................................... 20
2.2.1.1 Instrucionismo .................................................................................... 20
2.2.1.1 Sócio-construtivismo .......................................................................... 20
2.3 MOODLE ................................................................................................. 21
2.3.1 Estrutura ............................................................................................... 22
2.4 AGENTES ................................................................................................ 24
2.4.1 Agentes de interface ............................................................................. 26
2.4.2 Sistemas multiagente ............................................................................ 27
2.5 FRAMEWORKS E PADRÕES PARA SMA ......................................... 29
2.5.1 JADE Framework ................................................................................ 29
2.5.2 Jason...................................................................................................... 30
2.5.3 Quadro comparativo ............................................................................ 30
2.6 TRABALHOS SIMILARES .................................................................... 32
2.6.1 Agente pedagógico para recomendação de tutores ............................. 32
2.6.2 Agentes JADE integrados ao MOODLE ............................................. 33
2.7 CONSIDERAÇÕES SOBRE A FUNDAMENTAÇÃO ......................... 35
3. DESENVOLVIMENTO ............................................................................. 37
3.1 DESCRIÇÃO DO SISTEMA .................................................................. 37
3.2 REQUISITOS ........................................................................................... 40
3.2.1 Requisitos Funcionais ........................................................................... 40
3.2.2 Requisitos Não Funcionais ................................................................... 40
3.2.3 Regras de Negócio ................................................................................ 41
3.3 CASOS DE USO ....................................................................................... 41
3.4 SISTEMA MULTIAGENTE ................................................................... 43
3.4.1 Ontologia ............................................................................................... 43
3.4.2 Agente assistente ................................................................................... 45
3.4.3 Agente buscador ................................................................................... 49
3.4.4 Agente classificador .............................................................................. 50
3.4.5 Agente gerente ...................................................................................... 50
3.4.6 Agente controlador ............................................................................... 51
3.5 INTEGRAÇÃO COM O MOODLE ....................................................... 51
3.5.1 Banco de dados ..................................................................................... 51
3.5.2 Bloco ...................................................................................................... 54
3.5.3 Comunicação entre MOODLE e JADE .............................................. 57
3.6 IMPLANTAÇÃO E TESTES .................................................................. 59
3.6.1 Teste das telas apresentadas ................................................................ 60
3.6.2 Teste das funcionalidades de ajuda ao aluno ...................................... 62
3.6.3 Teste da classificação automática de questões .................................... 64
3.6.4 Desempenho do sistema com vários utilizadores simultâneos ........... 65
4. CONCLUSÕES .......................................................................................... 67
4.1 Trabalhos Futuros .................................................................................... 69
12
1. INTRODUÇÃO
A modalidade de EaD (Educação à Distância), diferentemente do que se pode pensar,
não é uma prática recente. O período exato de seu surgimento é controverso, sendo que
diversos autores, entre eles Alves (1998), datam seu surgimento no século XV, mesma época
da invenção da imprensa na Alemanha. Niskier (1999) cita que somente em 1880 houve a
primeira tentativa de estabelecer oficialmente um curso por correspondência, na Inglaterra,
porém a proposta foi rejeitada pelas autoridades locais. Os criadores da proposta a levaram
para os Estados Unidos, onde encontraram espaço na Universidade de Chicago. Em 1882,
surgiu o primeiro curso universitário de EaD naquela instituição, por correspondência. Desde
então, a EaD passou a ser difundida pelo mundo, principalmente em países como França,
Espanha e Inglaterra. Litto & Formiga (2009) explicam o destaque que estes países tiveram
pelo fato de exercerem um menor controle governamental na área da educação do que outros
países como o Brasil, o que deu abertura a iniciativas inovadoras na área, várias delas
envolvendo cursos á distância.
Embora popular, todavia, a EaD carregou por um bom tempo consigo o estigma de
uma forma de suprir lacunas das modalidades tradicionais, ou segundo as palavras do filósofo
francês Pierre Lévy (1996), ser uma espécie de estepe do ensino. Os meios de comunicação
utilizados não permitiam a mesma efetividade e interatividade de encontros presenciais,
acarretando na procura destes cursos apenas por aqueles desfavorecidos economicamente ou
geograficamente. Tudo mudou com o surgimento e evolução das tecnologias da informação,
sobretudo a Internet. Azevedo (1999) considera que podemos falar de uma EaD antes e depois
da Internet, pois com ela reuniram-se em um só meio as três formas de comunicação
possíveis: um-para-um, um-para-muitos e muitos-para-muitos. Somado essa característica ao
suporte de diversas mídias e à instantaneidade na troca de informações, a educação á distância
ganhou uma nova perspectiva, dando suporte á amplas possibilidades de interação entre seus
participantes. Rompeu-se a barreira do isolamento do estudante na EaD.
Neste novo cenário, os cursos de EaD devem prover como principal ferramenta um
grupo ou local onde os participantes possam interagir e construir o conhecimento de forma
coletiva e colaborativa, além de apenas acessar materiais de estudo (SANTOS, 2003). A
opção geralmente empregada é a utilização de um AVA (Ambiente Virtual de
Aprendizagem). O conceito de ambiente virtual de aprendizagem é amplo, envolvendo até
mesmo discussões sobre o real significado dos termos semânticos envolvidos. Lévy (1996),
13
por exemplo, define que o termo virtual possui pouca afinidade com o ilusório, mas que
denota ser fecundo e poderoso. Levando em conta a fala de Lévy (1996), Santos (2003) define
AVA como qualquer espaço que potencialize as possibilidades de construção do
conhecimento.
No contexto de cursos à distância que utilizam a Internet como canal de comunicação,
um AVA é concebido na prática por meio de um sistema web capaz de fornecer aos alunos
acesso a conteúdos, tarefas práticas e ferramentas de interação com os outros participantes,
tais como fóruns de discussão e chats. Estes ambientes muitas vezes são utilizados também
em cursos presenciais, como uma forma de ampliar a interatividade entre os participantes fora
da sala de aula e oferecer atividades complementares. A prática de combinar os modelos de
educação presencial e à distância é conhecida como blended learning.
Embora algumas instituições optem por desenvolver inteiramente seus próprios
ambientes virtuais, é comum que prefiram utilizar uma das ferramentas já existentes, seja ela
paga ou gratuita. Entre as alternativas gratuitas, destaca-se fortemente a plataforma
MOODLE, que possui cerca de 67.000 sites registrados (MOODLE, 2012b). Entre as
vantagens oferecidas pelo MOODLE, destacam-se o suporte a grandes volumes de usuários,
sua estrutura modular e o fato de ser um software livre, o que possibilita que a instituição de
ensino possa desenvolver seus próprios módulos e integrá-los ao MOODLE. Em seus
módulos nativos, MOODLE já oferece uma gama de funcionalidades, incluindo ferramentas
de comunicação síncrona e assíncrona.
Seguindo as tendências educacionais, a Assessoria de Informatização Educacional,
subordinada à Secretaria de Educação Municipal de Itajaí, responsável por implantar
tecnologias educacionais na rede municipal, após equipar todas as unidades escolares com
laboratórios de informática no decorrer dos últimos anos, desenvolveu recentemente um
ambiente virtual baseado na plataforma MOODLE, batizado de Educline. A proposta do
ambiente é oferecer cursos de formação continuada à distância para os educadores e uma
ferramenta auxiliar na aprendizagem dos alunos de escolas de ensino básico.
14
1.1 PROBLEMATIZAÇÃO
1.1.1 Formulação do Problema
A utilização de um ambiente virtual de aprendizagem gera um terreno fértil para
iniciativas que busquem aprimorar o processo de aprendizagem dos alunos. A área de
Inteligência Artificial pode contribuir neste aspecto, fornecendo técnicas que permitam extrair
dos dados brutos originados pela utilização do ambiente um conjunto de informações
relevantes sobre os alunos, como suas características e dificuldades. Através da identificação
das dificuldades que o aluno possui, podem ser formuladas diferentes soluções, permitindo
que o aluno escolha aquela que mais se encaixa ao seu perfil.
1.1.2 Solução Proposta
Considerando que um dos objetivos mais importantes do ambiente virtual Educline
quanto à sua utilização nas escolas é despertar maior interesse dos alunos por sua
aprendizagem, foi desenvolvido um assistente pessoal para incentivá-los e auxiliá-los nesta
meta, apontando os conteúdos em que possuem mais dificuldade e sugerindo meios de
aprimorarem-se.
A ideia é que cada aluno possua seu próprio assistente, desenvolvido como um agente
de interface integrante de um SMA (Sistema Multiagente). O assistente mantém internamente
uma base de conhecimento sobre o aluno, incluindo seu desempenho em cada conteúdo
estudado. Por meio de uma interface inserida no ambiente, contendo uma representação
gráfica, o assistente exibe comentários e sugestões de ajuda ao aluno, o qual pode enviar
comandos informando como deseja ser auxiliado.
No sistema multiagente também existem outros tipos de agente, responsáveis por
fornecer serviços de apoio aos assistentes, como pesquisa de recursos e controle do ciclo de
vida. Os agentes assistentes trocam mensagens entre si ou com os outros agentes para atingir
seus objetivos de forma colaborativa.
15
1.2 OBJETIVOS
1.2.1 Objetivo Geral
Desenvolver um sistema multiagente que ofereça assistência personalizada aos alunos
que usam o ambiente virtual de aprendizagem Educline, sugerindo-lhes formas de buscar
aprimoramento nos conteúdos que possuem maior dificuldade.
1.2.2 Objetivos Específicos
Estudar e descrever os conceitos pedagógicos envolvidos no uso de ambientes
virtuais de aprendizagem;
Estudar a estrutura da plataforma MOODLE e definir quais de seus módulos são
relevantes para o sistema proposto;
Pesquisar e analisar trabalhos semelhantes já realizados;
Buscar por ferramentas que auxiliem na implementação do sistema multiagente;
Elaborar a especificação e modelagem do sistema multiagente;
Implementar o sistema multiagente e implantá-lo no AVA Educline;
Planejar e realizar testes para avaliar o funcionamento do sistema multiagente.
1.3 METODOLOGIA
O desenvolvimento do sistema proposto neste trabalho de conclusão foi executado
através de cinco etapas: Criação do ambiente de desenvolvimento, Integração entre o SMA e
o ambiente MOODLE, Codificação do sistema multiagente, Implantação e Execução dos
testes.
Na etapa de Criação do ambiente de desenvolvimento, foi criada uma réplica da atual
versão do AVA Educline, sobre a qual foram realizados todos os testes preliminares na fase
de desenvolvimento. A réplica executou localmente na máquina usada para o
desenvolvimento, utilizando uma base de dados fictícia, na qual foram inseridos alguns
cursos, alunos e conteúdos.
A etapa de Integração entre o SMA e o ambiente MOODLE visou a criação do
mecanismo de comunicação entre o aluno e seu agente assistente. Foi utilizada uma extensão
do JADE, o WSIG (JADE Web Service Integration Gateway), para expor os serviços do SMA
16
por meio de webservices SOAP (Simple Object Access Protocol – Protocolo Simples de
Acesso a Objetos). Isso permitiu que a interface construída em PHP para o MOODLE
pudesse enviar comandos e receber informações diretamente do sistema multiagente, o qual é
uma aplicação Java.
A Codificação dos agentes pode ser considerada como a principal etapa, pois nela foi
desenvolvido o sistema multiagente propriamente dito. Utilizando a IDE NetBeans 7.2, JDK 6
e a versão 4.2 do framework JADE, foram codificados os cinco tipos de agentes especificados
no projeto. Durante o desenvolvimento, foram executados testes de funcionamento de cada
agente, de forma isolada, no caso dos classificadores e buscadores, e interagindo com os
demais, no caso dos assistentes. Também foram realizados vários ajustes progressivos para
alinhar o comportamento dos agentes e sua comunicação com a interface no AVA.
Na quarta etapa, Implantação, o sistema desenvolvido foi implantado no ambiente
virtual Educline. Foi criado um curso próprio para a realização dos testes na última etapa, no
qual foi instalada a interface do assistente virtual desenvolvida nas etapas anteriores.
A última etapa, Execução dos testes, consistiu na realização de testes com o objetivo
de analisar o funcionamento do sistema multiagente e constatar o cumprimento dos requisitos
funcionais.
1.4 ESTRUTURA DO TRABALHO
Este trabalho de conclusão está estruturado em quatro capítulos, sendo eles:
Introdução, Fundamentação Teórica, Desenvolvimento e Conclusões.
Na Introdução são apresentados a contextualização do projeto, o problema identificado
e a solução proposta, bem como os objetivos a serem cumpridos para a correta execução do
projeto e a metodologia utilizada.
A Fundamentação Teórica visa detalhar os assuntos envolvidos no projeto, analisar as
ferramentas que possam auxiliar na fase de desenvolvimento e apresentar projetos similares já
desenvolvidos. Entre os assuntos envolvidos, estão: aplicação de metodologias pedagógicas
em ambientes virtuais de aprendizagem, a estrutura da plataforma MOODLE, agentes e
sistemas multiagente. As ferramentas avaliadas foram os frameworks JADE e Jason.
No capítulo do Desenvolvimento, é apresentado o projeto e desenvolvimento do
sistema descrito na solução proposta. O projeto foi sintetizado nas duas primeiras subseções,
que abordam respectivamente uma descrição geral do sistema e seu conjunto de requisitos. As
17
demais subseções apresentam os detalhes de como cada agente do SMA foi implementado,
que tecnologias foram empregadas na integração com o MOODLE, que escolhas foram
tomadas em cada situação, e como ocorreram os testes de avaliação do sistema.
Por fim, no capítulo Conclusões, é realizada uma síntese de todo o trabalho realizado,
destacando e justificando as decisões tomadas durante o desenvolvimento do sistema.
18
2. FUNDAMENTAÇÃO TEÓRICA
Este capítulo destina-se à apresentação do ambiente virtual Educline, ao detalhamento
dos conteúdos teóricos abordados no projeto e à análise de ferramentas de desenvolvimento e
de trabalhos similares.
2.1 EDUCLINE
A Secretaria Municipal de Educação de Itajaí, criada como Secretaria de Educação
Cultura e Esporte pela Lei Municipal nº1523 (1977), possui como competência a execução
das atividades relativas à educação, como a execução de programas educacionais, a
coordenação das ações dos corpos docente e discente e a instalação e manutenção dos
estabelecimentos de ensino. Sua estrutura administrativa atual foi definida pela Lei
Complementar nº36 (2003), e é composta por cinco departamentos, uma equipe de
coordenação técnica e pelo gabinete do secretário e suas assessorias.
A Assessoria de Informatização Educacional nasceu no ano de 2001 como uma
divisão do Departamento de Ações Integradas, conforme definido pela Lei Complementar
nº14 (2001), porém após as alterações impostas pela Lei Complementar nº36 (2003), tornou-
se uma assessoria subordinada diretamente ao gabinete do secretário. As atribuições do
assessor de informatização educacional incluem:
Planejar, implementar e operacionalizar o sistema de informatização;
Coletar, organizar, consolidar e analisar os dados informativos educacionais;
Conceder suporte técnico e operacional da rede de comunicação de dados, dos
hardwares e softwares básicos, dos aplicativos de gestão e de gerenciamento de
banco de dados;
Promover a atualização tecnológica dos usuários;
Executar e controlar as atividades de transcrição de dados, operação e produção de
sistemas de informação.
Desde a sua criação, entretanto, a Assessoria de Informatização além de desempenhar
suas funções básicas, realizou importantes inovações na área tecnológica da rede municipal de
educação de Itajaí. Duas delas foram a disponibilização de laboratórios de informática para
todas as escolas da rede e o lançamento do portal da educação, site que centraliza todos os
serviços e informações disponibilizados pela secretaria. Atualmente, a assessoria é composta
pelo assessor e uma equipe de colaboradores que presta serviços de manutenção de
19
microcomputadores e redes, assistência aos usuários, coleta, análise e consolidação de dados e
desenvolvimento de sistemas informatizados.
Entre os projetos mais recentes da Assessoria de Informatização, está o ambiente
virtual de aprendizagem Educline. Concebido em junho de 2011, porém disponibilizado de
fato apenas em abril de 2012, o ambiente visa fornecer uma ferramenta de ensino à distância
para ser utilizada nos cursos de formação continuada dos educadores e nas escolas de ensino
básico como complemento às aulas presenciais. O ambiente foi criado utilizando o software
MOODLE, assim como o ambiente Sophia da UNIVALI (Universidade do Vale do Itajaí).
A disponibilização do Educline para os alunos de escolas é prevista para o segundo
semestre de 2012, pois ocorrerá após uma capacitação dos professores para utilizar os
recursos do ambiente, fator que é visto como um dos mais importantes pela Assessoria de
Informatização. Um dos principais objetivos do Educline quanto à utilização pelos alunos é
proporcionar aos mesmos um espaço de estudo diferenciado, onde a interatividade possa
incentivar o interesse pela aprendizagem.
2.2 AMBIENTES VIRTUAIS DE APRENDIZAGEM
Santos (2003) conceitua ambiente virtual de aprendizagem como um espaço onde
seres humanos e objetos técnicos interagem de forma a potencializar a construção de
conhecimentos. Segundo a autora, é tecnicamente possível a existência de um AVA sem a
utilização de qualquer mediação tecnológica, porém as tecnologias digitais de informação e
comunicação conferem ao AVA maior capacidade de potencializar e estruturar novas
sociabilidades, e consequentemente, novas aprendizagens.
O ciberespaço, meio de comunicação que reúne e integra uma infinidade de mídias e
interfaces digitais, pode ser considerado por si só um ambiente virtual de aprendizagem
universal, pela liberdade e flexibilidade que oferece. Por meio da Internet, principal ambiente
do ciberespaço, sujeitos e grupos podem criar e socializar seus saberes nos mais diversos
formatos, independentemente da localização geográfica dos envolvidos. Além disso, é
possível neste espaço a existência de comunidades virtuais fundadas para o fim específico da
aprendizagem, e cada uma delas pode constituir seu próprio AVA (SANTOS, 2003).
São vários os ambientes virtuais de aprendizagem produzidos e disponibilizados por
organizações no ciberespaço, para serem usados livremente (licenciamento livre) ou
comercialmente (licenciamento proprietário). Tais ambientes costumam fornecer uma lista de
20
recursos, incluindo ferramentas de comunicação síncrona e assíncrona, hipertextualidade e
suporte a diversos tipos de mídia (LIMA; INUZUKA; MOTA, 2012).
2.2.1 Metodologias pedagógicas em AVA
Santos (2003) enfatiza que não se deve avaliar um AVA apenas como uma ferramenta
tecnológica, pois é crucial que se avalie também a forma como os autores e gestores o
utilizam. Tal aspecto é definido pela filosofia pedagógica adotada, como exemplos o
instrucionismo e o sócio-construtivismo.
2.2.1.1 Instrucionismo
A filosofia instrucionista fundamenta-se no princípio de que a ação de ensinar está
fortemente vinculada à transmissão de informação, onde o professor assume a postura de
detentor do conhecimento que deve ser propagado para os alunos. Neste contexto, o
computador é visto como uma ferramenta capaz de auxiliar no processo de comunicação, e
consequentemente aperfeiçoar a transmissão da informação ao aluno. Uma das primeiras
abordagens instrucionistas utilizadas com computadores foi a CAI (Computer Assisted
Instruction – Instrução Auxiliada pelo Computador), onde o computador assume o papel de
máquina que “ensina” o aluno, tal como um professor (VALENTE).
As práticas instrucionistas aplicadas em ambientes virtuais de aprendizagem centram-
se na distribuição de conteúdos lineares e tarefas previamente elaboradas, como exercícios de
múltipla escolha ou enunciados de pesquisa, onde a interação entre os participantes é pouco
estimulada. A tutoria acaba se limitando ao gerenciamento burocrático do processo de ensino.
Dado que a principal característica de ambientes virtuais de aprendizagem é seu potencial
interativo, limitar-se às práticas instrucionistas pode causar a subutilização dos recursos
(SANTOS, 2003).
2.2.1.1 Sócio-construtivismo
Liderada por Vygotsky (1988), a corrente teórica sociointeraciosnista, base do sócio-
construtivismo, sustenta que a inteligência é construída através das relações recíprocas do
indivíduo com o meio. Para Vygotsky (1988), o papel da escola é oferecer um espaço onde as
pessoas se socializem e construam seus saberes em conjunto, além de aperfeiçoar
competências e estimular inteligências.
21
Diferentemente da filosofia instrucionista, onde o aluno apenas deve compreender e
reproduzir o conhecimento transmitido pelo professor, o sócio-construtivismo defende que o
aluno deve construir seu próprio conhecimento, sendo papel do professor auxiliá-lo neste
processo, intermediando sua relação com o saber. Em outras palavras, o conhecimento não é
oferecido pronto ao aluno, ao invés disso são oferecidos questionamentos que agucem sua
curiosidade, estímulos que o instiguem a refletir e buscar respostas. Erros fazem parte do
processo de aprendizagem, e devem ser apontados pelo professor, para que os próprios alunos
corrijam-nos (LIMA et al., 2012).
Ao transportar as práticas sócio-construtivistas para um AVA, é possível utilizar todo
seu potencial interativo, obtendo-se um espaço focado em dinâmicas participativas de
cooperação e de comunicação, regras flexíveis e desenvolvimento da criatividade e da
individualidade. Ferramentas de comunicação síncrona e assíncrona presentes nos AVAs
cibernéticos, como chats e fóruns de discussão, são exemplos de atividades que podem ser
usadas para estimular a interação entre os alunos e a troca de saberes, possibilitando a
construção da aprendizagem de forma cooperativa. O papel do tutor é acompanhar o aluno de
forma contínua, estimulando-o e auxiliando-o em seu processo de aprendizagem, estando
sempre atento ao fato de que cada ser humano tem seu ritmo e forma peculiar de aprender
(SANTOS, 2003).
2.3 MOODLE
MOODLE é um pacote de softwares destinado à criação de ambientes virtuais de
aprendizagem, também conhecidos como LMS (Learning Management System – Sistema de
Gestão de Aprendizagem). Criado por Martin Dougiamas, MOODLE é mantido como um
projeto de desenvolvimento global, apoiado sobre o paradigma de ensino sócio-construtivista
e sobre a filosofia do software livre, sendo disponibilizado gratuitamente sob a licença pública
GNU GPL 2.0 (MOODLE, 2012c).
O software pode ser instalado em qualquer servidor web capaz de executar código na
linguagem de programação PHP, requere um banco de dados relacional que utilize a
linguagem SQL e possui versões para os sistemas operacionais Windows, Mac e Linux.
Segundo o site do próprio MOODLE (2012b), o número de sites registrados que
utilizam o software cresceu de forma acelerada nos últimos anos, alcançando atualmente a
marca de mais de 66.000 sites.
22
2.3.1 Estrutura
MOODLE possui uma arquitetura modular, constituída pelo núcleo do sistema e um
conjunto de plugins que provêm as funcionalidades específicas, desde a autenticação de
usuários até as atividades dos cursos. Cada plugin é independente dos demais e se comunica
com o núcleo por meio de suas próprias APIs. Entretanto, todos os plugins seguem
convenções relativas às funcionalidades comuns, como instalação e configuração, o que
garante a consistência do sistema. A distribuição padrão do MOODLE já inclui consigo um
numeroso conjunto de plugins, o que a torna apta para ser utilizada sem a necessidade de
modificações (MOODLE, 2012a).
Apesar de possibilitar modificações, todos os sites construídos utilizando MOODLE
mantêm a mesma estrutura básica. Drechsler (2011) apresenta esta estrutura de forma
simplificada, dividindo-a nos seguintes itens:
Página inicial: geralmente utilizada para apresentar informações sobre a instituição
ou sobre o próprio ambiente virtual. Por padrão, é a primeira página que os
usuários visualizam ao se autenticar;
Categorias: utilizadas para agrupar cursos relacionados. Cada categoria pode
possuir uma ou mais categorias subordinadas, o que possibilita a criação de uma
estrutura hierárquica para melhor organização dos cursos;
Cursos: páginas onde os professores disponibilizam os materiais aos alunos. Cada
curso está contido em uma categoria.
Independente do layout empregado na organização dos itens, a página de um curso é
essencialmente constituída por um número variável de seções e blocos. As seções representam
os tópicos ou aulas do curso e é nelas que os professores publicam os recursos e as atividades.
Blocos são componentes visuais responsáveis por oferecer informações ou funcionalidades
adicionais à página, e podem estar presentes também em outras páginas do site (MOODLE,
2012c).
Um recurso é um item disponibilizado pelo professor para auxiliar na aprendizagem
dos alunos. Tal recurso pode ser um arquivo, um diretório, um texto, uma imagem, uma
página HTML embutida, um objeto de aprendizagem ou até mesmo um link para acessar
materiais externos ao ambiente. Os formatos de arquivos que podem ser publicados variam
desde documentos textuais e apresentações até imagens e vídeos.
23
Atividade é um nome genérico dado a um grupo de funcionalidades oferecido em um
curso. Em geral, uma atividade representa uma forma de o aluno interagir com o professor ou
com os outros alunos. O MOODLE contém 14 módulos de atividades em sua distribuição
padrão, entre eles o chat, o fórum, o questionário e o suporte a SCORM.
SCORM (Sharable Content Object Reference Model - Modelo de Referência para
Objetos Intercambiáveis de Conteúdo) é um conjunto de padrões técnicos usados para
produzir softwares de aprendizagem interoperáveis e reutilizáveis. Tais padrões garantem que
os LMS e os conteúdos educacionais online possam comunicar-se entre si. SCORM é
composto por três subespecificações que definem como os conteúdos devem ser empacotados
e descritos, como um LMS deve executar e comunicar-se com os conteúdos, e como o usuário
pode navegar entre as partes de um curso. Todo pacote SCORM possui um arquivo XML
denominado “imsmanifest.xml”, onde são descritos sua estrutura e seu conteúdo (RUSTICI
SOFTWARE, 2012).
A Figura 1 apresenta a tela de um curso no MOODLE, onde podem ser observados:
Dois blocos laterais à esquerda, sendo eles Atividades e Participantes;
Duas seções, localizadas no centro da página e delimitadas por retângulos;
Três atividades do tipo fórum, localizadas na segunda seção;
Dois recursos na segunda seção, sendo um documento e um link externo.
24
Figura 1. Página de um curso MOODLE
Fonte: MOODLE (2012c).
2.4 AGENTES
O termo agente não possui uma definição universalmente aceita na área da
Computação, embora exista um consenso de que todo agente é uma entidade autônoma, capaz
de operar sem intervenções. Entre as definições possíveis, um agente pode ser descrito como
um sistema computacional capaz de efetuar ações de forma autônoma sobre o ambiente em
que atua, visando alcançar seus objetivos de projeto (WOOLDRIDGE, 2002).
Para Russel e Norvig (2004), um agente é qualquer entidade capaz de analisar o
ambiente em que está inserido através de sensores e de efetuar ações sobre ele por meio de
atuadores. O agente pode ser caracterizado como racional se, para cada conjunto de
percepções obtidas, tomar a ação que maximize suas chances de sucesso, tendo como base a
evidência fornecida pela sequência de percepções e por qualquer conhecimento interno
armazenado.
25
Segundo Wooldridge e Jennings (1995), agentes podem ser considerados inteligentes
quando apresentam certo conjunto de características de inteligência. Os autores sugerem uma
lista de capacidades mínimas esperadas de um agente inteligente:
Pró-atividade: o agente pode realizar ações de sua própria iniciativa para satisfazer
seus objetivos;
Reatividade: o agente é capaz de perceber as mudanças ocorridas no ambiente e
responder a elas em tempo hábil, buscando satisfazer seus objetivos;
Habilidade social: o agente é capaz de interagir com outros agentes (ou seres
humanos) por meio de uma linguagem de comunicação, visando satisfazer seus
objetivos.
A pró-atividade representa o comportamento padrão de um sistema computacional
funcional, onde perante certas pré-condições, uma sequência de tarefas é executada para
alcançar uma meta definida. Esse comportamento, no entanto, assume que o ambiente não se
alterará enquanto as tarefas estiverem sendo executadas, o que o torna inviável para ambientes
dinâmicos. A reatividade é a característica que provê ao agente capacidade de adaptar seu
comportamento diante dos eventos que ocorram no ambiente (WOOLDRIDGE; JENNINGS,
1995). A habilidade social é necessária apenas quando o agente necessita comunicar-se com
outras entidades, geralmente outros agentes, e será abordada em detalhes na Subseção 2.4.2.
Quanto à sua estrutura interna, agentes inteligentes podem ser classificados em dois
grandes grupos, reativos e cognitivos. Agentes reativos possuem uma estrutura simples, sem
uma representação de conhecimento formal, sendo seu comportamento inteligente fruto de
suas interações com o ambiente. Já os agentes cognitivos possuem uma representação
simbólica explícita do seu ambiente como componente principal de sua base de
conhecimento, além de disporem de memória sobre suas ações passadas (RUSSEL;
NORVIG, 2004).
Nwana (1996) estabelece uma tipologia de agentes com sete tipos distintos, baseando-
se em suas características comportamentais, capacidades e propósitos. Entre os tipos de
agentes citados estão:
Agentes colaborativos, que enfatizam a cooperação com outros agentes para
atingir seus objetivos. Podem possuir capacidade de aprendizado, mas limitada
e menos importante que a habilidade social;
26
Agentes de interface, que enfatizam a interação com o ser humano e o
fornecimento de assistência ao usuário;
Agentes móveis, que possuem como principal característica a capacidade de se
locomover entre hosts de uma rede, ou até mesmo viajar pela Internet, e
retornar ao host de origem após executar suas tarefas;
Agentes inteligentes, cujos aspectos mais importantes são sua capacidade de
aprendizado e a representação de seu conhecimento sobre o ambiente.
O que define o tipo de um agente é a característica na qual é focado, porém é comum
que um agente utilize vantagens de outros tipos. Um agente de interface, por exemplo, pode
usufruir da capacidade de negociar com outros agentes, tal como um agente colaborativo, e
ser capaz de aprender, como um agente inteligente (NWANA, 1996).
2.4.1 Agentes de interface
Agentes de interface são assistentes pessoais autônomos que monitoram e analisam as
ações do usuário na aplicação. Este tipo de agente possui a função de cooperar com o usuário,
realizando certas tarefas por ele (NWANA, 1996). Podem ou não possuir uma representação
gráfica, e quando possuem, são chamados de agentes animados ou agentes personificados.
A principal motivação para criação de agentes de interface é automatizar tarefas
rotineiras que o usuário executaria de forma manual. Limpar a caixa de e-mails ou buscar
informações em grandes bases de dados são exemplos de tarefas que consomem tempo e
podem tornar-se entediantes e repetitivas. O objetivo de inserir agentes para realizar tais
tarefas é reduzir a sobrecarga de trabalho e informação do usuário (MAES, 1994).
Um agente de interface observa constantemente a utilização do software, sugerindo
maneiras melhores de executar as tarefas. Segundo Maes (1994), um agente de interface pode
se adaptar através de quatro maneiras para oferecer uma melhor assistência:
Observando e imitando as ações do usuário;
Recebendo feedback positivo ou negativo do usuário;
Recebendo instruções explícitas do usuário;
Solicitando informações de outros agentes.
27
2.4.2 Sistemas multiagente
Ambientes muito complexos para serem monitorados por apenas um agente
caracterizam a necessidade de um SMA (Sistema Multiagente). Um SMA é formado por um
conjunto de agentes que interagem entre si por meio de uma linguagem comum e podem
exercer algum tipo de controle sobre uma parte do ambiente. Cada agente é totalmente
autônomo e possui seus próprios interesses (WOOLDRIDGE, 2002).
Em um SMA, o comportamento inteligente é dependente das interações entre os
agentes. Uma vez que cada agente é autônomo, um agente não pode simplesmente forçar
outro a realizar ações ou alterar seu estado interno diretamente. Se um agente deseja que o
outro realize certa tarefa, deve comunicar-lhe seu desejo. A capacidade de cooperar é,
portanto, fundamental para os agentes que integram um SMA para que se atinjam os objetivos
globais (WOOLDRIDGE, 2002).
Para que possam cooperar agentes precisam se comunicar. Segundo Mendonça, Souto-
Maior e Padilha (2007), para que a comunicação entre os agentes se torne possível é
necessário que eles utilizem uma ACL (Agent Communication Language – Linguagem de
Comunicação de Agentes) e uma ontologia em comum.
Na área de Inteligência Artificial, o termo ontologia define um domínio específico,
podendo ser interpretado como um conjunto de entidades com suas relações, restrições,
axiomas e vocabulário. Mendonça et al. (2007) apontam como principais benefícios do uso de
ontologias:
Oportunidade para desenvolvedores de reutilizar ontologias e bases de
conhecimento;
Disponibilidade de uma vasta gama de ontologias e bases de conhecimento
prontas para uso;
Mapeamento entre formalismos de representação de conhecimento, que permite a
um agente acessar o conhecimento de outro agente.
Enquanto a ontologia diz respeito ao conteúdo das mensagens trocadas, uma ACL
geralmente especifica a estrutura dessas mensagens. O objetivo de uma ACL é permitir que
agentes, que podem inclusive ser heterogêneos, possam se comunicar. Duas das ACLs mais
28
comuns são a KQML (Knowledge Query and Manipulation Language – Linguagem de
Consulta e Manipulação de Conhecimento) e a FIPA-ACL (MENDONÇA et al., 2007).
KQML é uma linguagem que define um formato padronizado para as mensagens
trocadas entre agentes. Comparando uma mensagem KQML a um objeto de uma linguagem
OO, sua performativa seria equivalente à classe do objeto, e seus parâmetros são pares de
chaves e valores, tal como os atributos. A performativa basicamente descreve a intenção do
agente (WOOLDRIDGE, 2002).
O Quadro 1 mostra um exemplo de mensagem KQML, cuja performativa é “ask-one”.
Os parâmetros da mensagem são descritos por seu nome precedido pelo caractere dois-pontos,
seguido de seu valor. Os parâmetros da mensagem apresentada definem respectivamente seu
conteúdo, o agente que a enviou, a linguagem usada no conteúdo e a ontologia utilizada.
(ask-one
:content (PRICE IBM ?price)
:receiver stock-server
:language LPROLOG :ontology NYSE-TICKS
)
Quadro 1. Exemplo de mensagem KQML
Fonte: Wooldridge (2002).
A FIPA-ACL é uma ACL desenvolvida pela FIPA (Foundation for Intelligent
Physical Agents – Fundação para agentes físicos inteligentes), uma organização que promove
a utilização de tecnologias baseadas em agentes. FIPA fornece uma coleção de padrões que
garantem a interoperabilidade entre agentes heterogêneos e entre agentes e outras tecnologias
(FIPA, 2012).
A estrutura de mensagem definida pela FIPA-ACL é idêntica à da KQML, e os
parâmetros são muito similares. A diferença mais importante entre as duas é o conjunto de
performativas fornecido. Segundo Wooldridge (2002), FIPA-ACL define 20 performativas
para descrever a intenção da mensagem, entre elas:
CFP (Call for proposals): representa um pedido por propostas para realizar uma
ação. O conteúdo de uma mensagem CFP informa a ação desejada e as condições
29
sob as quais deve ser executada. Geralmente mensagens deste tipo são enviadas
para vários agentes, com o intuito de receber várias propostas;
PROPOSE: representa uma proposta de ação, e geralmente é enviada em resposta
a uma performativa CFP;
ACCEPT-PROPOSAL: informa a aceitação de uma proposta recebida;
REJECT-PROPOSAL: informa a recusa de uma proposta, informando o motivo
no conteúdo da mensagem;
REQUEST: representa um pedido direto a outro agente para realizar uma ação,
sem imposição de condições;
AGREE: enviada em resposta a uma performativa REQUEST para confirmar que
a ação será realizada;
INFORM: mensagem informativa que contém uma afirmação, a qual o agente
acredita ser verdadeira.
2.5 FRAMEWORKS E PADRÕES PARA SMA
2.5.1 JADE Framework
JADE (Java Agent DEvelopment Framework) é um framework desenvolvido na
linguagem de programação Java cujo objetivo é simplificar a implementação de sistemas
multiagente, garantindo total cumprimento com as especificações da FIPA.
O escopo dos padrões FIPA engloba a comunicação entre os componentes de um
sistema multiagente, o ciclo de vida dos agentes e os serviços básicos necessários, abstraindo
a estrutura interna dos agentes. A plataforma de agentes do JADE oferece todos os
componentes obrigatórios especificados pelos padrões da FIPA, como serviço de nomes,
serviço de páginas amarelas, protocolos de interação e transporte de mensagens. Toda
comunicação entre os agentes é realizada através de mensagens na linguagem FIPA-ACL
(JADE, 2012).
A plataforma dos agentes pode estar distribuída entre diversas máquinas que podem
inclusive possuir diferentes sistemas operacionais. Neste caso, cada máquina possui um
container de agentes que dá todo o suporte a sua execução. Os agentes possuem a capacidade
de se mover entre os contêineres da plataforma, caso seja necessário (JADE, 2012).
30
Os agentes do JADE são executados como uma thread por agente, porém o framework
também suporta que cada agente realize suas tarefas de forma paralela, através do
escalonamento de comportamentos (behaviours) cooperativos. Para implementar um agente,
deve-se criar uma classe Java que estenda a classe Agent, definir os comportamentos e
associá-los ao agente (JADE, 2012).
2.5.2 Jason
Jason é um interpretador para uma versão estendida da linguagem AgentSpeak.
AgentSpeak é uma linguagem de programação orientada a agentes, especificada segundo os
conceitos e lógicas do modelo BDI (Belief-Desire-Intention – Crença-Desejo-Intenção)
(JASON, 2012).
BDI é um modelo abstrato que define três características básicas para agentes
inteligentes: suas crenças, desejos e intenções. Respectivamente, eles correspondem à base de
conhecimento do agente sobre seu ambiente (informacional), seus objetivos e prioridades
(motivacional) e seu plano de ação atual. No modelo BDI, tipicamente diz-se que um agente é
capaz de escolher e executar um plano de ação com base em suas percepções do ambiente. A
escolha de um plano captura o componente deliberativo do agente (NUNES, 2007).
Alguns dos recursos disponibilizados pelo framework Jason são:
Comunicação entre agentes baseada na teoria do ato da fala;
Oferece mecanismo para tratar falhas nos planos dos agentes;
Possibilidade de executar um sistema multiagente distribuído através de uma rede;
Suporte para desenvolvimento de ambientes usando a linguagem Java;
Possui IDE própria.
2.5.3 Quadro comparativo
Para efeitos de comparação dos frameworks estudados, foi elaborado um quadro
comparativo com as principais características de cada um, incluindo o paradigma em que se
baseiam, as linguagens que utilizam, disponibilidade da documentação e existência de casos
de integração com o software MOODLE.
31
JADE Jason
Base Especificações FIPA Modelo BDI
Linguagem de
programação
(definição dos agentes)
Java, através de classes base
para os agentes, mensagens
ACL e comportamentos.
AgentSpeak para definição do
comportamento dos agentes;
Java para definição de
ambientes.
Linguagem externa
(estrutura das mensagens)
FIPA-ACL, as mensagens são
criadas e enviadas
programaticamente, usando
classes Java.
KQML, as mensagens são
criadas e enviadas usando
expressões da linguagem
AgentSpeak.
Linguagem interna
(conteúdo das mensagens)
Suporta qualquer uma. FIPA
fornece a FIPA-SL, mas
utilizá-la não é obrigatório.
Suporta qualquer uma.
Documentação Disponível, incluindo desde a
documentação oficial, que
satisfaz a maior parte das
necessidades, até diversos
exemplos práticos.
Disponível, porém escassa.
Além da documentação
oficial há pouco material
disponível, e não foi
encontrada nenhuma
informação sobre como
implantar um sistema real que
execute fora do ambiente de
desenvolvimento fornecido.
Casos de integração com
MOODLE
Encontrado um caso no
trabalho similar exposto na
Subseção 2.6.2.
Não encontrado.
Quadro 2. Comparação entre os frameworks estudados
Conforme pode ser observado no Quadro 2, o JADE permite que todo os agentes
sejam programados inteiramente em Java, enquanto o Jason exige a utilização de uma
linguagem própria para descrever o comportamento do agente segundo o modelo BDI.
Embora não seja necessariamente uma desvantagem, este fato faz com que o Jason possua
uma curva de aprendizagem maior. Também foi constatado que a documentação do JADE é
bem mais abundante e detalhada, com vários exemplos práticos disponíveis. Todas as
características observadas favoreceram, portanto, a adoção do JADE como ferramenta de
desenvolvimento do sistema multiagente.
32
2.6 TRABALHOS SIMILARES
Foram encontrados e analisados dois sistemas já desenvolvidos que possuem
similaridades com o sistema proposto. Ambos os sistemas encontrados são fruto de trabalhos
acadêmicos e foram implementados sobre o ambiente MOODLE. O primeiro sistema
analisado não é um SMA, mas um agente de interface que é capaz de indicar ao aluno outras
pessoas que possam auxiliar-lhe em um assunto específico, promovendo assim o aprendizado
cooperativo. O outro sistema analisado é um SMA capaz de monitorar a participação dos
alunos nos fóruns e foi desenvolvido utilizando o framework JADE.
2.6.1 Agente pedagógico para recomendação de tutores
Em Ribeiro, Reategui e Boff (2007) foi introduzido um agente pedagógico em um
ambiente MOODLE, com o propósito de adicionar um componente sócio-afetivo à interface
do sistema e promover a interação entre os alunos.
Agente pedagógico é um agente de interface que atua em um sistema aplicado à
educação. A principal função deste tipo de agente é interagir com o aluno e fornecer suporte
às tarefas de aprendizagem, geralmente representando a figura de um professor ou instrutor
(NWANA, 1996).
O agente pedagógico desenvolvido, chamado Cadinho, possui como principal
funcionalidade a recomendação de tutores. Com base nos dados coletados no log do
MOODLE, Cadinho identifica alunos que aparentem estar com dificuldades em uma atividade
e aplica algoritmos para recomendá-los outros alunos que podem ajudá-lo. O aluno com
dificuldades pode então interagir com o aluno tutor pela ferramenta de chat do MOODLE, que
foi modificada para incluir uma avaliação da tutoria (RIBEIRO et al., 2007).
O algoritmo de recomendação de tutores utilizado em Ribeiro et al. (2007) leva em
conta quatro fatores ao avaliar os alunos:
Humor: o humor do aluno define se ele está apto a prover uma orientação efetiva.
O valor do humor é estabelecido pelo próprio aluno no momento de entrada no
ambiente de aprendizagem;
Performance: representa o desempenho do aluno em um determinado assunto. É
calculado sobre as atividades teóricas e práticas relativas ao assunto em questão;
33
Aceitação: demonstra a eficácia do aluno como tutor e é determinado pela média
das notas dadas pelos alunos que solicitaram orientação;
Iterações: média das comunicações iniciadas e respondidas pelo aluno.
Figura 2. Agente de recomendação de tutores
Fonte: Ribeiro et al. (2007).
2.6.2 Agentes JADE integrados ao MOODLE
O objetivo do trabalho de Lin et al. (2010) foi desenvolver uma metodologia para
incorporar agentes JADE no MOODLE, com o intuito de aprimorar as funcionalidades do
ambiente. Para exemplificação, foram desenvolvidos agentes de monitoramento para o
módulo de fórum, visando automatizar a análise da participação dos alunos nesta modalidade
de atividade.
Os agentes foram desenvolvidos utilizando o framework JADE, e desempenham suas
atividades sem qualquer intervenção humana. A integração dos agentes JADE com o
ambiente MOODLE é realizada por meio da interface de configuração do curso no ambiente,
apresentada na Figura 3, por meio da qual o tutor pode ativar ou desativar o monitoramento
34
dos fóruns e definir o intervalo de tempo entre as verificações das postagens dos alunos (LIN
et al., 2010).
Figura 3. Configuração do monitoramento de fóruns no MOODLE
Fonte: Lin et al. (2010).
Para implementação do sistema de monitoramento dos fóruns, foram especificados e
desenvolvidos três tipos de agentes em (LIN et al., 2010):
Agente de tempo: responsável por instanciar e inicializar os demais agentes em
intervalos de tempo definidos na configuração do sistema;
Agente cliente do fórum: responsável por interpretar as chamadas feitas ao agente
monitor do fórum;
Agente monitor do fórum: responsável por acessar o banco de dados do MOODLE
e realizar todas as verificações relativas à participação dos alunos nos fóruns.
Os agentes monitores acessam o banco de dados do MOODLE de forma direta, por
meio da API JDBC (Java Database Connectivity) do Java. Estes agentes executam uma série
de tarefas com base nos dados obtidos, incluindo:
35
Calcular o número de postagens de cada aluno;
Procurar por alunos que não participaram no fórum;
Identificar discordâncias entre dois alunos, verificando postagens que possuem
mais de três réplicas envolvendo os mesmos alunos;
Inserir novas postagens no fórum, alertando sobre a inatividade de alunos;
Enviar um e-mail ao tutor do curso contendo as informações colhidas.
2.7 CONSIDERAÇÕES SOBRE A FUNDAMENTAÇÃO
Este capítulo iniciou-se com a apresentação do ambiente virtual de aprendizagem
Educline, que foi criado pela Secretaria Municipal de Educação de Itajaí para oferecer ensino
à distância aos professores e alunos da rede municipal de ensino. O grupo de usuários
relevante para este trabalho é o de alunos, que engloba estudantes dos anos finais do ensino
fundamental, com idades entre 12 e 15 anos.
Em seguida, foi pesquisado e descrito o conceito de ambiente virtual de aprendizagem,
e como as filosofias e metodologias pedagógicas influenciam na forma como um AVA é
utilizado. O sócio-construtivismo foi apontado como uma alternativa interessante ao
tradicional instrucionismo, uma vez que é capaz de usufruir melhor do potencial interativo
dos ambientes virtuais cibernéticos e promover a aprendizagem cooperativa.
Foi descrito detalhadamente o software MOODLE, o qual foi utilizado para o
desenvolvimento do AVA Educline. Entre os conceitos pertinentes a este trabalho, citou-se o
que são atividades e recursos, e qual é a estrutura da página de um curso. A interface do
sistema proposto foi desenvolvida como um bloco, que é um componente visual e modular
que pode ser inserido na página de um curso.
O conceito de agentes também foi abordado neste capítulo. O sistema proposto é um
multiagente, pois é composto por vários agentes capazes de comunicar-se entre si. Para
realizar a interação entre o sistema e os alunos do ambiente, foram implementados agentes de
interface que atuam como assistentes pessoais, oferecendo ferramentas de auxílio de
aprendizagem.
Para auxiliar na etapa de desenvolvimento do sistema, foram estudados frameworks
orientados a agentes. Ambos os frameworks estudados, JADE e Jason, mostraram-se boas
alternativas para o projeto, cada um utilizando arquiteturas e conceitos distintos. O framework
JADE, que é baseado nos padrões FIPA, foi escolhido para utilização, principalmente pela
existência de um caso prévio e bem sucedido de integração com o MOODLE no trabalho de
36
Lin et al. (2010). Outros fatores que determinaram a escolha foram a disponibilidade de uma
documentação de qualidade e o fato do JADE não exigir o aprendizado de linguagens de
programação adicionais para utilizá-lo, como é o caso da linguagem AgentSpeak do Jason.
Considerando que o foco do trabalho não é o aprendizado de uma ferramenta, optou-se pela
alternativa que ofereceu menor curva de aprendizagem.
Por fim, foram analisados dois casos de trabalhos similares. Foi adotada a ideia de
recomendação de tutores apresentada em Ribeiro et al. (2007), por ser uma forma de
incentivar o aprendizado cooperativo apoiado pelo sócio-construtivismo. O método de
avaliação de desempenho dos alunos utilizado no sistema desenvolvido é similar ao
apresentado em Lin et al. (2010), entretanto, a atividade usada como referência é o
questionário ao invés do fórum de discussões.
37
3. DESENVOLVIMENTO
Neste capítulo é apresentado o sistema concebido neste trabalho de conclusão,
primeiramente fornecendo uma descrição de sua arquitetura, bem como seu conjunto de
requisitos, e posteriormente, detalhando as tecnologias e métodos empregados em cada
componente desenvolvido. Por fim, são demonstrados o processo de implantação do sistema
no ambiente virtual Educline e os testes realizados para avaliar seu funcionamento.
3.1 DESCRIÇÃO DO SISTEMA
O sistema multiagente desenvolvido, batizado posteriormente como Erudio, teve como
objetivo fornecer um assistente pessoal aos alunos de escolas públicas da rede municipal de
ensino de Itajaí que utilizam o ambiente virtual de aprendizagem Educline. O assistente
proposto deveria auxiliar na aprendizagem destes alunos utilizando métodos diferenciados, a
fim de atender diferentes perfis de aluno. Para alcançar o objetivo, definiu-se que o sistema
deveria possuir ao menos as seguintes características:
Ser capaz de reconhecer os conteúdos em que o aluno obteve menor desempenho,
através da análise das atividades que realizou;
Incentivar o autodidatismo do aluno sugerindo-lhe recursos de aprendizagem de
fontes internas e externas, que estejam relacionados aos conteúdos em que
apresentou menor desempenho;
Incentivar o aprendizado cooperativo apoiado pelos princípios sócio-
construtivistas, indicando ao aluno outros usuários conectados que possam
oferecer ajuda nos conteúdos em que obteve menor desempenho.
A atividade escolhida para determinar o desempenho do aluno nos conteúdos foi o
questionário. Embora seja uma atividade de caráter individualista, ligada aos métodos
instrucionistas, é capaz de verificar com exatidão o quanto o aluno compreendeu os conceitos
relacionados a um conteúdo. O uso dos questionários neste caso, portanto, não pretende
constituir uma forma de avaliação do aluno, apenas verificar seu entendimento de conteúdos
específicos.
Estruturalmente, o sistema Erudio foi segmentado em três camadas, duas delas
responsáveis respectivamente pelo processamento e apresentação das informações, e a terceira
responsável por realizar a comunicação entre estas. A necessidade da existência desta terceira
camada se deu pela razão de que o sistema multiagente foi inteiramente desenvolvido na
38
linguagem Java, enquanto a interface de apresentação exibida ao aluno foi construída como
parte do MOODLE, que é escrito em PHP.
Para implementação da camada de processamento, constituída pelo SMA
propriamente dito, foi utilizado o framework JADE, e consequentemente, os padrões
arquiteturais da FIPA. Os agentes que compõe o sistema ficam contidos em um container de
execução JADE, e se enquadram em cinco tipos distintos:
Classificador: agentes deste tipo possuem a função de consultar os questionários
dos cursos e vincular suas questões à tags que classifiquem seu conteúdo. Sua
utilidade no sistema é secundária, pois a tarefa que desempenha é normalmente
realizada de forma manual pelos usuários que cadastram as questões;
Assistente: cada aluno conectado ao ambiente possui uma instância de um agente
assistente responsável por auxiliá-lo. Quando o aluno solicita ajuda de outros
alunos, por exemplo, o agente assistente pergunta aos demais assistentes se seus
alunos estão aptos a oferecer este auxílio;
Gerente: possuem primariamente a função de gerenciar o ciclo de vida dos agentes
assistentes dos alunos do seu curso. Existe um gerente para cada curso em é
detectada uma instância do módulo do Erudio. Outra motivação para a criação dos
agentes gerentes foi dar a possibilidade de tomar medidas de auxílio aos alunos por
curso, além das medidas individuais já fornecidas pelos assistentes;
Buscador: quando um assistente detecta um conteúdo em que o aluno
aparentemente enfrenta dificuldades, ele aciona o agente buscador para pesquisar
por recursos de aprendizagem. O agente buscador utiliza as tags dos conteúdos
desejados como parâmetro para pesquisar na base de dados interna do AVA e
também em repositórios externos. Ao encontrar os recursos, ele retorna ao
assistente uma lista de objetos contendo os links para acessá-los;
Controlador: agente responsável por gerenciar a criação dos agentes gerentes e
classificadores. O controlador permanece ocioso a maior parte do tempo,
executando suas ações entre intervalos de longa duração. O classificador é criado e
executado incondicionalmente em intervalos fixos de tempo, enquanto os gerentes
são instanciados apenas para os cursos que utilizam o módulo do Erudio.
Na Figura 4, é ilustrada de forma simplificada a arquitetura do sistema, incluindo os
agentes descritos. Como se pode observar, cada aluno conectado ao AVA possui um agente
39
assistente associado. Todos os agentes existentes podem acessar a base de dados do AVA, que
engloba as tabelas dedicadas ao SMA. O agente buscador, ao ser acionado por um assistente,
pode realizar uma pesquisa por recursos externos através da rede LOP2P, que será descrita na
Subseção 3.4.2.
Figura 4. Arquitetura do sistema multiagente Erudio
A camada de apresentação do sistema foi desenvolvida como um bloco do MOODLE.
Um bloco é um tipo de componente do MOODLE que pode ser inserido e posicionado
facilmente em qualquer página de curso. O bloco de título Assistente Erudio consiste
basicamente de uma representação visual do assistente, que apresenta seu humor, um trecho
contendo uma fala ao aluno, e caso tenha sido detectado um conteúdo em que o aluno enfrenta
dificuldades, as opções de ajuda disponíveis.
Por fim, para criação da camada que interliga processamento e apresentação, foi
utilizada uma extensão do JADE, o WSIG (JADE Web Services Integration Gateway), que é
capaz de expor os serviços dos agentes como web services SOAP. Desta forma, a camada de
40
apresentação consegue obter diretamente dos agentes as informações que deve exibir, no
formato XML.
3.2 REQUISITOS
Foram elaborados os requisitos básicos que o sistema deveria cobrir, segmentados nas
categorias de funcionais, não funcionais e regras de negócio.
3.2.1 Requisitos Funcionais
Os requisitos funcionais descrevem as funcionalidades que o sistema deve oferecer. Os
requisitos funcionais do sistema proposto são:
RF01 – O sistema deve identificar os conteúdos em que o aluno obteve menor
desempenho.
RF02 – O sistema deve ser capaz de indicar recursos relacionados aos conteúdos em
que o aluno obteve menor desempenho.
RF03 – O sistema deve ser capaz de indicar ao aluno outros usuários conectados que
possam ajudá-lo em um conteúdo em que obteve baixo desempenho.
RF04 – O sistema deve notificar o aluno caso outro usuário solicite sua ajuda.
3.2.2 Requisitos Não Funcionais
Os requisitos não funcionais indicam características técnicas que o sistema deve
possuir. Os requisitos não funcionais do sistema proposto são:
RNF01 – O sistema deve ser desenvolvido como um sistema multiagente.
RNF02 – O sistema deve ser representado por um personagem animado inserido na
interface do ambiente virtual MOODLE.
RNF03 – A comunicação do sistema com os alunos deve ser realizada através de
linguagem simples e utilizar aspectos emotivos nas falas.
RNF04 – As atividades usadas para avaliar o desempenho do aluno em um conteúdo
devem ser do tipo questionário.
RNF05 – Devem ser usadas apenas ferramentas livres e gratuitas para implementação
do sistema.
41
3.2.3 Regras de Negócio
As regras de negócio visam detalhar as funcionalidades do sistema, como regras e
restrições. As regras de negócio para o sistema proposto são:
RN01 – Os conteúdos abordados em uma questão são definidos pelas tags associadas
a ela.
RN02 – Uma questão pode abordar mais de um conteúdo.
RN03 – O desempenho do aluno em um conteúdo é definido pela porcentagem de
acertos nas questões respondidas associadas a ele.
RN04 – Conteúdos que possuem menos de três questões respondidas são
desconsiderados na avaliação de desempenho.
3.3 CASOS DE USO
O diagrama de casos de uso exibido na Figura 5 e seus respectivos cenários visaram
descrever como deveria ocorrer a interação dos usuários com o sistema proposto. Todos os
casos previstos foram atendidos na implementação, com duas alterações:
No caso de uso UC02 foi subtraído o Passo 6, fazendo com que o aluno não precise
aceitar uma proposta de ajuda antes de se encaminhado ao chat;
No caso de uso UC03 foi retirado o Passo 3, pois o sistema desenvolvido busca e
sugere os recursos automaticamente, sem necessitar de uma ordem do aluno.
Figura 5. Casos de uso do sistema desenvolvido
UC01 – Visualizar pedidos de ajuda
Deve ser permitido ao aluno visualizar os pedidos de ajuda que outros alunos lhe
fazem e ser capaz de aceitá-los ou não. Caso aceite o pedido, ambos os alunos serão
encaminhados para ferramenta de chat do ambiente para que possam se comunicar.
42
Cenário Principal
1. O aluno acessa a página do curso.
2. O sistema exibe os pedidos de ajuda que forem recebidos de outros alunos.
3. O aluno clica na opção „Sim‟ para aceitar o pedido de ajuda.
4. O sistema encaminha o aluno para o chat do ambiente virtual.
Cenário Alternativo – Recusa do pedido
Após o Passo 2, caso o aluno prefira ignorar o pedido de ajuda clicando em „Não‟, o
sistema ocultará o pedido e informará o remetente da não aceitação.
UC02 – Solicitar ajuda de outro aluno
Deve ser permitido ao aluno buscar por outro aluno conectado que possa oferecer
auxílio em um conteúdo. Caso um aluno receba um pedido de ajuda de outro e o aceite,
ambos serão encaminhados para ferramenta de chat do ambiente para que possam se
comunicar.
Cenário Principal
1. O aluno acessa a página do curso.
2. O sistema exibe o conteúdo no qual o aluno obteve menor desempenho.
3. O aluno seleciona a opção de solicitar ajuda de outro aluno.
4. O sistema busca por outro aluno conectado que obteve bom desempenho no
conteúdo.
5. O sistema exibe o aluno que aceitou oferecer ajuda e pede confirmação.
6. O aluno confirma que deseja conversar com o outro.
7. O sistema encaminha o aluno para o chat do ambiente virtual.
Cenário Alternativo – Nenhum aluno encontrado
Após o Passo 4, caso não seja encontrado nenhum aluno conectado que tenha
condições de oferecer ajuda no conteúdo especificado, o sistema exibe mensagem de
notificação e oferece a opção de buscar recursos como alternativa de obter ajuda.
43
UC03 – Buscar recursos auxiliares
Deve ser permitido ao aluno buscar por recursos que possam lhe ajudar no conteúdo
em que tem dificuldades.
Cenário Principal
1. O aluno acessa a página do curso.
2. O sistema exibe os conteúdos nos quais o aluno obteve menor desempenho.
3. O aluno seleciona a opção de buscar recursos adicionais sobre o conteúdo.
4. O sistema pesquisa por recursos relativos ao conteúdo.
5. O sistema exibe uma lista com os links para os recursos encontrados.
3.4 SISTEMA MULTIAGENTE
Para implementação do SMA foram especificados cinco tipos de agente, cada um com
responsabilidades distintas: o controlador, o classificador, o buscador, o gerente e o assistente.
Estes agentes desempenham, respectivamente, as funções de controle de execução,
classificação do conteúdo abordado nos questionários, pesquisa de recursos de aprendizagem,
gerência dos cursos e assistência dedicada aos alunos.
Além dos agentes criados, existem também os agentes padrões do JADE, responsáveis
por fornecer os serviços básicos da plataforma, incluindo registro de nomes e de serviços.
Todos os agentes do sistema residem em um container JADE, e caso seja necessário, podem
ser criados mais de um container. Os agentes que residem em containeres diferentes podem
comunicar-se como fariam normalmente.
3.4.1 Ontologia
Apesar de não ter sido elaborada uma ontologia formal para o sistema multiagente,
utilizou-se um mecanismo do framework JADE para criação de um conjunto de classes Java
que representam os elementos ontológicos envolvidos. Tal mecanismo possui como base a
classe BeanOntology, que define a ontologia em si, e as interfaces AgentAction e Concept, que
definem respectivamente ações de agentes e entidades ontológicas que podem ser adicionadas
à ontologia. Qualquer classe que siga os padrões JavaBeans pode implementar AgentAction
ou Concept, não sendo necessário escrever nenhum método adicional. Uma vez definida uma
44
classe de ontologia comum para os agentes, é possível transportar instâncias dos elementos
ontológicos por meio das mensagens.
As classes que implementam AgentAction representam ações que os agentes realizam
ao enviar uma mensagem. Para o SMA Erudio, foram criadas as seguintes classes desta
categoria:
ContatarAssistente: ação especial enviada a um agente assistente pela camada que
comunica o SMA à apresentação. Corresponde a uma solicitação para atualizar a
apresentação ou realizar um comando que o aluno tenha requisitado;
PedirAjuda: ação que corresponde a um pedido de ajuda de um aluno para outro;
OferecerAjuda: ação que corresponde a uma oferta de ajuda de aluno para outro;
AceitarAjuda: ação que corresponde à aceitação de uma oferta de ajuda de outro
aluno;
RequisitarRecursos: ação enviada por um agente assistente a um agente buscador,
solicitando recursos relacionados a um conteúdo específico.
Classes do tipo Concept constituem entidades de domínio do sistema, estando
intrinsecamente ligadas ao contexto em que ele atua. Foram definidas seis classes de domínio:
Curso: representa um curso do ambiente virtual. Tem como um de seus atributos a
lista de alunos que estão conectados no momento;
Aluno: representa um aluno, de um curso. Possui além de nome e número de
identificação, uma lista dos conteúdos estudados. Cada agente assistente está
ligado a uma instância desta classe;
Conteudo: representa um conteúdo estudado por um aluno. Contém como atributos
um nome, o número de questões que o aluno respondeu sobre ele e a média atual
de acertos, além da identificação da tag associada;
Recurso: representa um recurso de aprendizagem, contendo uma descrição,
categoria, link para acessá-lo e o conteúdo ao qual está relacionado. Quando o
agente Buscador responde a uma requisição de recursos, responde-a com uma lista
de objetos deste tipo. A categoria serve para identificar se o recurso é um arquivo
simples, uma página web ou um objeto de aprendizagem;
Questao: representa uma questão, com nome e enunciado. É utilizada
exclusivamente pelo agente Classificador;
45
Apresentacao: representa a tela que deve ser exibida ao aluno. Cada assistente
mantém uma instância desta classe, e atualiza-a constantemente. Quando a camada
de apresentação contata o assistente, ele envia como resposta este objeto.
3.4.2 Agente assistente
O assistente é o agente de interface responsável por identificar as dificuldades do
aluno e oferecer-lhe ferramentas de auxílio. Cada aluno conectado ao ambiente possui uma
instância de um assistente a seu dispor e comunica-se com ele por meio de um bloco na
interface do ambiente virtual.
O agente assistente é inicializado recebendo como parâmetro o aluno pelo qual é
responsável. Conhecendo seu aluno, ele carrega as informações relativas ao perfil e
desempenho do mesmo em cada conteúdo, define a tela a ser exibida na camada de
apresentação, e entra em estado de espera, atualizando seu modelo em intervalos regulares e
aguardando comandos do aluno ou mensagens de outros assistentes. Os comandos que o
aluno pode enviar ao seu assistente são:
Solicitar ajuda de outro aluno em um conteúdo;
Responder a um pedido de ajuda de outro aluno.
O diagrama de sequência apresentado na Figura 6 demonstra os passos do processo de
solicitação de ajuda de outro aluno:
Primeiramente, o aluno envia o comando de solicitação ao seu assistente, o qual é
recebido como um objeto da classe ContatarAssistente encapsulado em uma
mensagem de performativa INFORM;
O assistente envia uma mensagem CFP contendo um objeto PedirAjuda aos
demais assistentes, solicitando propostas de ajuda para o conteúdo desejado;
Os assistentes que recebem a mensagem CFP analisam se o seu aluno está apto a
oferecer ajuda naquele conteúdo, e em caso positivo, exibem o pedido ao mesmo;
Uma vez que um aluno aceita oferecer ajuda, seu assistente envia uma mensagem
PROPOSE contendo um objeto OferecerAjuda ao assistente do aluno solicitante;
O assistente do aluno solicitante pode receber várias mensagens de proposta,
porém aceitará a primeira que receber, enviando ao agente remetente uma
mensagem ACCEPT-PROPOSAL com um objeto AceitarAjuda. As demais
46
propostas serão negadas por meio de mensagens com performativa REJECT-
PROPOSAL sem conteúdo;
O aluno solicitante é notificado que alguém aceitou lhe ajudar. Seu assistente
então abre uma janela de chat; para que este possa comunicar-se com seu
colaborador;
O assistente do aluno colaborador também abre uma janela de chat para seu aluno.
Figura 6. Diagrama de sequência da solicitação de ajuda de outro aluno
O processo de busca e apresentação de recursos de aprendizagem, diferentemente do
pedido de ajuda, é realizado automaticamente pelo agente, sem requerer uma solicitação do
aluno. Além disso, ele também envolve uma troca menor de mensagens, conforme pode ser
constatado pelo diagrama de sequência da Figura 7:
47
O assistente identifica o conteúdo em que o aluno obteve menor desempenho;
O assistente envia uma mensagem de pedido de busca ao agente buscador, com
performativa REQUEST e contendo um objeto RequisitarRecursos, que informa o
conteúdo que deve ser pesquisado;
O agente buscador realiza a tarefa de busca interna por recursos, e caso não
encontre, consulta fontes externas por meio da rede LOP2P, que será abordada na
próxima subseção;
Após terminar a pesquisa, o agente buscador informa ao assistente os recursos
encontrados e seus respectivos links, por meio de uma lista de objetos Recurso
contidos em uma mensagem INFORM;
O assistente exibe ao seu aluno a lista de links para os recursos encontrados.
Figura 7. Diagrama de sequência da solicitação de ajuda de recursos
Para identificar o desempenho do aluno em cada conteúdo e definir a tela a ser exibida
na camada de apresentação, o agente assistente mantém uma base de conhecimento de seu
aluno, contendo a lista de todas as questões já respondidas, número total de acertos e erros por
48
conteúdo, quantidade de pedidos de ajuda atendidos e rejeitados e a data do último acesso no
ambiente. As informações são extraídas do banco de dados do AVA e a maior parte é
carregada em um objeto da classe Aluno, para que possa ser facilmente transmitida via
mensagens.
Como o assistente de um aluno só existe enquanto ele está conectado no ambiente, os
dados que são gerados durante sua execução precisam ser armazenados em memória
persistente sempre que seu ciclo de vida chegar ao fim. Para isso foram criadas duas tabelas
dedicadas ao módulo do Erudio, uma para guardar informações do aluno em si, e outra para
armazenar as conversas no chat.
As sugestões apresentadas pelo agente assistente ao aluno são definidas pelo estado
atual de seu modelo. Para sugerir que o aluno busque auxílio em um determinado conteúdo, o
assistente verifica o conteúdo no qual ele obteve menor desempenho. A Tabela 1 exemplifica
como ocorre a avaliação de desempenho de um aluno em conteúdos de matemática. O
desempenho é definido pelo percentual de acertos nas questões respondidas sobre o conteúdo,
porém foi inserida uma regra adicional na avaliação que desconsidera conteúdos com menos
de três questões, na tentativa de evitar amostras pequenas demais. Portanto, no exemplo, a
amostra do conteúdo de Equações de 2º grau seria desconsiderada pelo agente assistente, e o
conteúdo considerado o de menor desempenho do aluno seria Matrizes.
Tabela 1. Cálculo de avaliação de desempenho do aluno nos conteúdos
Conteúdo Questões
respondidas
Soma dos
acertos
Percentual de
acertos (%)
Frações 14 7 0,5
Equações de 2º grau 1 0 0
Matrizes 5 1 0,2
Os critérios para um assistente decidir se o seu aluno está apto ou não a atender um
pedido de ajuda são o seu desempenho no conteúdo solicitado, que possui peso de relevância
0.7 (setenta por cento), e a porcentagem de pedidos aceitos anteriormente, com peso 0.3
(trinta por cento). A porcentagem de pedidos aceitos foi considerada na decisão já que alguns
alunos podem destacar-se em prestar ajuda aos colegas, enquanto outros podem não ter
interesse em atuar colaborativamente.
49
3.4.3 Agente buscador
A tarefa de pesquisar por recursos referentes a um conteúdo é desempenhada pelo
agente buscador. Ele recebe de um agente assistente as tags que representam o conteúdo
desejado, acessa a base de dados do MOODLE, bem como repositórios externos de objetos de
aprendizagem, e pesquisa por recursos que possuam em seus dados descritivos índices de
conteúdo correspondentes às tags.
O agente buscador desempenha de forma simplificada o papel de um SRI (Sistema de
Recuperação de Informação). Recuperação de informação é uma subárea da ciência da
computação que estuda o armazenamento e recuperação automática de documentos digitais.
Um SRI, segundo Cardoso (2009), tipicamente realiza três processos:
Indexação, a criação de estruturas de dados descritivos dos documentos
armazenados com base em seu conteúdo textual;
Especificação de consulta, a etapa que formula uma consulta com base em
palavra-chave que representem os documentos desejados;
Recuperação, o retorno de documentos cujos índices descritivos correspondam às
palavras-chave da consulta, ordenados por ordem de relevância.
O agente buscador possui a responsabilidade de exercer os processos de especificação
de consulta e recuperação dos objetos. A indexação dos recursos de aprendizagem é realizada
por seus próprios publicadores, através dos dados de identificação e descrição do recurso. As
palavras-chave usadas na especificação das consultas são fornecidas pelo agente assistente
que requisita a busca, retiradas das tags das questões que o aluno errou.
As buscas em repositórios de objetos de aprendizagem externos utiliza uma rede
LOP2P. LOP2P é uma arquitetura para compartilhamento de objetos de aprendizagem entre
instituições de ensino, desenvolvida no projeto de mestrado de Santiago (2009), baseada no
modelo peer-to-peer. A arquitetura permite publicar objetos para compartilhamento, buscar
objetos compartilhados e solicitar o download dos mesmos. Foi utilizado um protótipo
LOP2P desenvolvido em (SANTIAGO, 2009) para permitir ao agente buscador pesquisar
fontes externas quando o repositório do AVA Educline não supre a necessidade.
50
3.4.4 Agente classificador
O objetivo do agente classificador é analisar os questionários existentes no ambiente
virtual e associar suas questões à tags que simbolizem os conteúdos abordados. Ao ser criado,
este agente realiza as seguintes tarefas em sequência:
Identifica todas as questões existentes na base de dados que não possuem nenhuma
tag associada;
Para cada questão identificada, concatena seu nome a seu enunciado, e extrai da
string resultante um conjunto de no máximo 10 palavras-chave;
Cria tags das palavras-chave encontradas no enunciado, caso ainda não existam;
Associa as questões às tags do conjunto de palavras-chave;
Encerra seu ciclo de vida, eliminando-se.
O próprio MOODLE possui um módulo responsável pelo gerenciamento de tags, que
fornece mecanismos e tabelas no banco de dados para o cadastro de tags e inclusão de
associações. Uma interface no ambiente para associar tags manualmente às questões também
já existe, portanto a intenção de inserir o agente classificador é automatizar esta tarefa para os
tutores dos cursos, usando a estrutura já existente.
Considerando que o Classificador fornece uma funcionalidade complementar ao
objetivo geral previsto para o sistema, a única forma de tratamento empregada sobre a string
usada para extração das palavras-chave foi a retirada prévia de palavras consideradas
irrelevantes, como artigos, preposições e pronomes. Após a extração destas palavras, todas as
remanescentes se tornam potenciais palavras-chave.
3.4.5 Agente gerente
Para cada curso existente no ambiente virtual que possui uma instância do módulo do
Erudio, existe também uma instância de um agente gerente. Este agente possui como
responsabilidade principal identificar quando um aluno do curso que gerencia realiza o acesso
no ambiente e criar um agente assistente para o mesmo. Após um período de inatividade do
aluno, o gerente também se encarrega de marcar o respectivo assistente em uma lista, para que
ele posteriormente encerre sua execução.
A existência de um gerente para cada curso também visou possibilitar a inserção de
funcionalidades relativas à turma como um todo. Seria possível em uma futura adaptação, por
exemplo, adicionar uma verificação no comportamento do gerente para identificar o conteúdo
51
em que a maioria dos alunos do curso possui dificuldade, o que possibilitaria a tomada de
ações de auxílio globais, além das individuais que os assistentes já provêm.
3.4.6 Agente controlador
O agente controlador possui apenas a responsabilidade de criar e inicializar instâncias
dos gerentes e classificadores de acordo com a necessidade. Existe apenas uma instância do
agente controlador, que é criada no início da execução do sistema e persiste por tempo
indeterminado, enquanto o sistema multiagente estiver em execução.
O agente controlador possui dois comportamentos executados continuamente:
Verificar os cursos em que existe uma instância do bloco do Erudio e criar um
agente gerente para cada um deles;
Em intervalos de tempo pré-determinados, instanciar o agente classificador para
realizar uma nova classificação das questões cadastradas na base de dados. Foi
inserido um tempo arbitrário de uma hora na versão desenvolvida.
3.5 INTEGRAÇÃO COM O MOODLE
3.5.1 Banco de dados
O banco de dados da plataforma MOODLE segue o modelo relacional e possui mais
de 250 tabelas, que por padrão recebem o prefixo “mdl_” em seus nomes. Para facilitar a
compreensão das tabelas e suas relações, os desenvolvedores do software adotaram um padrão
de nomenclatura, composto pelo nome do módulo ao qual a tabela pertence concatenado ao
complemento que descreve o conteúdo da tabela. Desta forma, para utilizar os dados de um
módulo, deve-se buscar pelas tabelas nomeadas como “mdl_modulo_complemento”, entender
como elas se relacionam e como se conectam às tabelas principais do MOODLE.
A documentação do MOODLE denomina cerca de 50 tabelas como tabelas principais
(core tables). Estas tabelas estão vinculadas a funcionalidades básicas do software e também
são agrupadas em módulos, dos quais se pode citar: usuários, papéis e permissões, inscrições,
cursos, grupos e agrupamentos, logs e blocos.
O módulo da atividade questionário, que foi utilizado pelos agentes assistentes para
determinar o desempenho dos alunos nos conteúdos, armazena seus dados em mais de dez
tabelas, as quais possuem o prefixo mdl_quiz ou mdl_question. As tabelas com prefixo
52
mdl_question guardam as informações relativas às questões em si, enquanto as mdl_quiz
armazenam as instâncias de questionários existentes nos cursos.
Para obter os acertos dos alunos em cada questão respondida foram utilizadas quatro
tabelas, expostas no diagrama ER da Figura 8. A tabela mdl_question_attempts guarda os
registros da última tentativa dos alunos em cada questão, porém não fornece a nota obtida e
tampouco a identificação do aluno. Para obter tais informações, foi necessário cruzar os dados
com a tabela mdl_question_attempts_steps, que registra os passos de cada tentativa. O último
passo de uma tentativa revela se o aluno acertou a questão e que nota obteve.
Figura 8. Diagrama ER do módulo de questões (simplificado)
O módulo de tags foi utilizado para realizar a classificação das questões. O diagrama
ER na Figura 9 apresenta de forma simplificada as tabelas usadas pelo agente classificador. O
classificador utiliza apenas a tabela mdl_tag, que armazena as tags em si, e a tabela de
53
instâncias, que indica as associações de tags a objetos. Em um registro de associação existe o
tipo do objeto classificado (itemtype), que pode ser, por exemplo, uma questão, e os valores
que referenciam a tag e o objeto, respectivamente tagid e itemid.
Figura 9. Diagrama ER do módulo de tags (simplificado)
Além de usar as tabelas de módulos nativos do MOODLE, foram criadas duas tabelas
específicas para o módulo do Erudio, seguindo o padrão de nomenclatura dos outros. A tabela
mdl_erudio_assistant armazena variáveis internas dos assistentes quando eles encerram sua
execução. Foi escolhido armazenar apenas os dados que não podem ser extraídos das outras
tabelas, que são basicamente as quantidades de pedidos de ajuda que o aluno aceitou e
rejeitou. A outra tabela, mdl_erudio_chat_message, simplesmente guarda as mensagens do
chat, já que foi desenvolvido um próprio para o Erudio devido às limitações do chat original
do MOODLE. A Figura 10 ilustra as tabelas criadas e suas relações com a tabela de usuários.
54
Figura 10. Diagrama ER das tabelas do Erudio
3.5.2 Bloco
No MOODLE, um bloco é um componente com representação visual que fornece um
grupo de funcionalidades e pode ser facilmente adicionado ou removido da página de um
curso. Assim como o restante do MOODLE, os blocos são escritos na linguagem PHP, e o
conteúdo exibido é gerado por código HTML.
A criação de um novo bloco é uma tarefa simples, bastando criar ao menos dois
arquivos PHP. O primeiro deles é o bloco em si, que deve ser codificado como uma classe que
estenda block_base, a classe base de todos os blocos fornecida pelo MOODLE. A classe do
bloco deve ser nomeada com o prefixo “block_”. O segundo arquivo requerido deve ser
nomeado como “version.php” e possui meramente a função de informar a data da versão do
bloco, para caso sejam lançadas atualizações futuramente.
O bloco que foi desenvolvido para interface do agente assistente, o qual recebeu o
título de Assistente Erudio, possui os seguintes elementos:
55
Representação visual do assistente, que demonstra uma expressão de humor
condizente com suas falas. Quando o agente exibe uma notificação de baixo
desempenho em algum conteúdo, por exemplo, sua expressão é de preocupação;
Falas do agente, que utilizam linguagem simples e direta para passar ao aluno
algum tipo de informação, seja uma mensagem de boas vindas ou algum tipo de
notificação;
Botões, que permitem ao aluno enviar comandos ao seu agente assistente. Se um
aluno obteve baixo desempenho em determinado conteúdo, por exemplo, será
exibido um botão para pedir ajuda a outros alunos, que ao ser clicado, enviará ao
agente uma notificação do evento, para que este realize os procedimentos
correspondentes;
Links de recursos encontrados, que direcionam o aluno diretamente para o arquivo,
página da web ou objeto de aprendizagem correspondente.
A Figura 11 apresenta três das principais telas do bloco. Na primeira o assistente
apenas dá as boas vindas ao aluno, seu humor apresentado como feliz. A tela do meio, em que
o assistente expressa preocupação, é exibida quando ele detecta que o aluno teve desempenho
abaixo da média em um conteúdo. Podem-se notar o botão para buscar ajuda de outro aluno e
os links de conteúdos encontrados. A última tela, de humor neutro, é exibida quando o aluno
recebe um pedido de ajuda de outro, oferecendo as opções de atendê-lo ou não. Além destas
telas, existe uma de elogio, exibida quando o aluno obtém desempenho além da média em
todos os conteúdos, e outra versão da tela de sugestões, que expressa humor neutro, quando é
detectado um conteúdo em que o aluno pode aprimora-se mas obteve uma nota dentro da
média.
56
Figura 11. Telas de apresentação do bloco Assistente Erudio
Como parte integrante do bloco do Erudio, foi desenvolvida uma tela de chat bastante
simplificada com suporte a comunicação um para um, para ser utilizada nos casos em que um
aluno pede ajuda ao outro. Como se observa na Figura 12, o chat é exibido em uma janela
separada no navegador, permitindo que o aluno possa comunicar-se com seu ajudante sem
estar preso a uma tela do ambiente virtual. As mensagens são armazenadas em uma tabela
própria do Erudio, citada na subseção anterior.
A razão pelo qual se optou pela criação de um sistema de chat próprio foi evitar a
criação de instâncias de chats do MOODLE, que não poderiam ser ocultadas na interface do
mesmo, o que causaria grande poluição visual. Outras razões levantadas foram o fato do chat
do MOODLE permitir que qualquer um possa acessar e participar da conversa, e não permitir
que pessoas de cursos distintos possam conversar.
57
Figura 12. Janela de chat do bloco Assistente Erudio
3.5.3 Comunicação entre MOODLE e JADE
Um dos principais aspectos no desenvolvimento do sistema multiagente Erudio foi
determinar como a camada de apresentação, constituída pelo bloco do MOODLE, se
comunicaria com o agente assistente do aluno, situado em um container JADE possivelmente
sendo executado em uma máquina distinta. Tal comunicação é necessária para que a
apresentação possa manter-se atualizada e para que o aluno possa enviar comandos ao seu
assistente. Após ser realizada pesquisa sobre as tecnologias disponíveis, constatou-se a
existência de uma extensão do próprio JADE, denominada WSIG, que é capaz de expor
serviços de agentes na forma de web services SOAP. Diante das alternativas, como o uso de
sockets, optou-se por utilizar esta extensão por ter sido considerada uma solução mais
elegante e menos propensa a falhas.
O WSIG é uma aplicação web escrita em Java e composta por dois elementos
principais, um Servlet e um agente JADE. O Servlet WSIG é o verdadeiro responsável por
interceptar as requisições SOAP e converter seu conteúdo em objetos AgentAction que são
repassados ao agente. O agente WSIG recebe as ações e as encaminha para o agente capaz de
58
cumpri-las, obtendo o resultado da execução e repassando-o de volta ao Servlet. Uma vez que
o Servlet recebe um resultado de execução, ele o converte em uma resposta SOAP e envia ao
cliente que fez a requisição, encerrando o ciclo (JADE BOARD, 2012).
O agente WSIG também é o responsável por registrar os agentes capazes de atender as
solicitações externas, e seus respectivos serviços. Ele obtém tais informações nas descrições
de serviços publicadas pelos agentes no DF. Para cada agente registrado, é também criado um
arquivo WSDL (Web Services Description Language – Linguagem de Descrição de Web
Services), que auxilia os clientes SOAP a obter informações sobre os serviços disponíveis
(JADE BOARD, 2012).
A versão do WSIG utilizada para comunicar a camada de apresentação do Erudio com
os agentes foi a 2.0, executada em um servidor de aplicações JBoss 7.0.2 na mesma máquina
do container principal do JADE. O bloco MOODLE utiliza a classe SoapClient, nativa do
PHP, para acessar o web service do agente assistente do aluno. O único serviço
disponibilizado pelos agentes é o ContatarAssistente, correspondente à AgentAction de
mesmo nome, e o resultado retornado é sempre um objeto da classe Apresentacao, que
engloba todos os dados necessários para construir a tela exibida ao aluno. A requisição SOAP
também pode conter um parâmetro de solicitação, que indica uma ação que o assistente deve
desempenhar antes de enviar a resposta.
Na Figura 13, obtida com o uso do agente sniffer do JADE, que funciona como um
monitor dos outros agentes, observa-se uma sequência de mensagens REQUEST e INFORM
trocadas entre o agente WSIG e um agente assistente. Com o intuito de manter a apresentação
atualizada, o bloco Erudio realiza continuamente requisições assíncronas (AJAX), em
intervalos de tempo fixo, ao web service do assistente do aluno. Tal requisição é passada ao
agente WSIG que envia uma mensagem REQUEST ao agente assistente correspondente, o
qual a processa e devolve uma mensagem INFORM com os dados de apresentação
atualizados.
59
Figura 13. Troca de mensagens na atualização da apresentação
3.6 IMPLANTAÇÃO E TESTES
A implantação do sistema Erudio no ambiente virtual Educline se deu basicamente em
dois passos. Primeiramente, foram instalados e configurados o sistema multiagente JADE e a
aplicação WSIG em uma máquina localizada na mesma rede que o servidor do AVA. Os
requisitos para estes dois componentes foram uma JVM 6 ou superior e um container de
Servlets Java para executar o WSIG, sendo que o utilizado foi o JBoss 7 por ser a opção
padrão adotada na Prefeitura de Itajaí. O segundo passo foi copiar o diretório do bloco do
Erudio para o Educline, que o detectou e o instalou automaticamente.
Uma vez concluída a implantação, tornou-se possível inserir o bloco Assistente Erudio
em qualquer curso existente. Foi criado um curso exclusivamente para a realização dos testes,
no qual foram inseridas atividades de questionário com questões já classificadas. Os testes
realizados se dividiram em quatro verificações principais:
Correção das telas apresentadas ao aluno diante seu desempenho nos conteúdos;
Correção das funcionalidades de ajuda ao aluno;
Precisão da classificação automática de questões;
60
Desempenho do sistema com vários utilizadores simultâneos.
3.6.1 Teste das telas apresentadas
O teste das telas apresentadas visou constatar que o sistema é capaz de exibir as
informações corretas de acordo com o desempenho obtido pelo aluno nos conteúdos que
estudou, além de averiguar o cumprimento do requisito funcional RF01 (identificação dos
conteúdos em que o aluno obteve menor desempenho).
Como primeiro caso foram respondidas corretamente todas as questões de um
questionário. A tela resultante pode ser vista na Figura 14. Esta tela de felicitação ao aluno é
mostrada quando ele atinge um bom desempenho em todos os conteúdos estudados. Na
implementação do sistema, foi considerado como desempenho BOM uma porcentagem de
acertos de 0.85 (oitenta e cinco por cento) ou superior.
Figura 14. Caso de obtenção de desempenho bom em todos os conteúdos
No segundo caso, foram respondidos ambos os questionários criados, alternando entre
acertos e erros propositais. Como se observa na Figura 15, os únicos conteúdos sobre o quais
foram respondidas três questões ou mais foram Algoritmo e Ordenação, o que elimina os
demais conteúdos da análise de desempenho realizada pelo agente assistente. Já que o menor
desempenho considerado foi obtido em Ordenação, mas a nota está dentro do limite
REGULAR, que foi definido como 0.7 (setenta por cento), a tela exibida elogia o aluno ao
mesmo tempo em que oferece sugestões de estudo no conteúdo.
61
Figura 15. Caso de obtenção de desempenho regular em um conteúdo
Como último teste, foram realizados novamente os questionários, desta vez
objetivando obter um desempenho considerado baixo em um conteúdo, ou seja, abaixo de 0.7
(setenta por cento). A Figura 16 mostra a tela exibida ao se errar todas as quatro questões do
conteúdo de Algoritmo. Nota-se que a tela é muito semelhante à obtida no caso anterior,
porém o humor apresentado pelo assistente denota preocupação pelo baixo desempenho do
aluno.
62
Figura 16. Caso de obtenção de desempenho baixo em um conteúdo
3.6.2 Teste das funcionalidades de ajuda ao aluno
O teste das funcionalidades de ajuda teve como objetivo comprovar que o sistema
desenvolvido cumpriu corretamente os requisitos funcionais RF02, RF03 e RF04, referentes
às formas de interação do agente assistente com o aluno.
Primeiramente foi testada a opção de buscar a ajuda de outro aluno (requisitos RF03 e
RF04). O teste foi realizado com três alunos do mesmo curso conectados, sendo que nenhum
deles havia rejeitado um pedido de ajuda anteriormente, e apenas um possuía desempenho
bom no conteúdo solicitado. A Figura 17 apresenta em destaque as mensagens trocadas entre
os agentes durante o processo. O assistente 312_11451 disparou mensagens CFP para todos
os demais agentes assistentes, porém apenas o aluno do assistente 312_8715 estava apto a
oferecer auxílio, sendo, portanto, o único que visualizou o pedido de ajuda. Após o pedido ter
sido aceito pelo aluno ajudante, as mensagens PROPOSE e ACCEPT-PROPOSAL foram
trocadas entre os agentes assistentes envolvidos, e as telas de ambos os alunos mudaram para
o estado de chat, permitindo que conversassem em uma janela independente.
63
Figura 17. Mensagens trocadas entre agentes durante um pedido de ajuda
Para o teste da funcionalidade de buscar e indicar recursos de aprendizagem relativos
ao conteúdo em que o aluno obteve menor desempenho (requisito RF02) foram inseridos dois
recursos em dois cursos distintos. Os recursos em questão eram dos tipos arquivo e link
externo, e tinham em seu título ou descrição as mesmas palavras usadas nas tags das questões
que foram respondidas incorretamente. O agente assistente foi capaz de detectar e apresentar
ambos, mesmo estando em cursos distintos. A Figura 18 mostra o assistente enviando uma
mensagem REQUEST ao buscador, e recebendo como resposta uma mensagem INFORM. A
mensagem de resposta possui em seu conteúdo a lista de recursos encontrados.
64
Figura 18. Mensagens trocadas entre agentes durante uma busca de recursos
3.6.3 Teste da classificação automática de questões
O teste da funcionalidade adicional de classificar automaticamente as questões foi
realizado com questões de português e história já existentes no ambiente virtual antes da
implantação do sistema. Nenhuma destas questões possuía tags classificatórias. O Quadro 3
apresenta algumas das questões e as tags geradas para elas após a execução do agente
classificador. Pode-se perceber que o classificador só é capaz de gerar tags coerentes quando
o tema da questão aparece explicitamente no enunciado. Além disso, muitas palavras com
sentido muito amplo ou pouco relevante acabaram sendo consideradas na classificação.
Nome Enunciado Tags geradas
Assinale a alternativa
correta
A escravidão no Brasil teve início
com a produção de açúcar na
primeira metade...
assinale; alternativa; correta;
escravidão; Brasil; produção;
açúcar; ...
0,5 pontos Você acabou de assistir e ler um
dos discursos de Adolf Hitler...
acabou; assistir; ler; discurso;
Adolf; Hitler; ...
Pronome Leia atentamente a frase e
classifique o pronome...
pronome; leia; atentamente;
frase; classifique; ...
Aponte o erro Aponte o erro ortográfico aponte; erro; ortográfico; ...
Analise a tirinha e
responda a questão
A charge do cartunista Benett foi
publicada no jonal...
analise; tirinha; responda;
questão; charge; ...
Preencha com x ou ch Preencha com x ou ch: _ingar,
mo_ila, ca_umba...
preencha; x; ch.
Quadro 3. Classificações automáticas de questões realizadas pelo sistema
65
3.6.4 Desempenho do sistema com vários utilizadores simultâneos
Este teste visou verificar possíveis alterações no desempenho do sistema com o
crescimento do número de usuários simultâneos. Contudo, só foi possível realizá-lo com duas
turmas de vinte alunos, totalizando o máximo de quarenta usuários. Uma vez que o sistema
multiagente foi executado em uma máquina com o sistema operacional Windows 7, utilizou-
se a ferramenta Gerenciador de Tarefas disponibilizada pelo mesmo para monitorar a
utilização do processador e o consumo de memória.
A Figura 19 mostra o processamento e consumo da memória quando não havia
nenhum usuário conectado ao ambiente, antes da criação de qualquer agente assistente. Já a
Figura 20 apresenta os mesmos dados após os quarenta alunos acessarem o ambiente, o que
causou a instanciação de quarenta agentes assistentes. Como se pode observar, o consumo de
processador e memória praticamente manteve-se o mesmo. Além disso, nenhum problema de
desempenho foi relatado pelos alunos participantes, sendo que quatro deles utilizaram o
recurso do chat fornecido pelo Erudio.
Figura 19. Dados de processamento e consumo de memória sem usuários conectados
66
Figura 20. Dados de processamento e consumo de memória com quarenta usuários
É evidente que caso o sistema fosse utilizado com turmas de todas as escolas do
município, a quantidade de usuários seria bem mais elevada, provavelmente exigindo a
criação de múltiplos contêineres JADE para suprir a demanda. Ainda assim, o sistema se
apresentou bastante estável, e o consumo de memória acrescentado por cada agente assistente
mostrou-se aceitável.
67
4. CONCLUSÕES
A ideia central que motivou a elaboração e desenvolvimento do sistema
computacional contemplado neste trabalho técnico-científico foi incorporar ao ambiente
virtual de aprendizagem Educline um assistente virtual que auxiliasse os alunos nos conteúdos
em que apresentassem dificuldades.
Foi definido que o assistente virtual deveria ser modelado como um agente de
interface, já que ele representa uma entidade real e seria responsável por auxiliar o aluno,
exercendo papel semelhante ao de um tutor. Todavia, ainda durante a elaboração da proposta
inicial do projeto, constatou-se que apenas um agente não poderia lidar com a complexidade
de atender de forma satisfatória a quantidade de alunos que utilizará o AVA simultaneamente,
já que cada aluno deve ser tratado de forma independente. Optou-se então por uma arquitetura
multiagente, onde existiriam vários agentes assistentes, cada um responsável por auxiliar um
dos alunos conectados no ambiente.
A etapa de estudo, apresentada no capítulo da Fundamentação Teórica, visou reunir
conhecimentos sobre os tópicos envolvidos no projeto proposto, avaliar ferramentas que
pudessem auxiliar na etapa de desenvolvimento do sistema e analisar trabalhos similares já
realizados. Foi estudado o conceito de ambiente virtual de aprendizagem e algumas das
metodologias pedagógicas empregadas nestes espaços, a estrutura do software MOODLE, e
os aspectos relativos a agentes e sistemas multiagente. As ferramentas avaliadas foram os
frameworks JADE e Jason, que auxiliam na implementação de SMAs, porém utilizando
padrões e arquiteturas distintas.
A análise de trabalhos similares forneceu contribuições importantes ao projeto,
especificamente na forma como os agentes avaliam o desempenho dos alunos nos conteúdos e
que serviços de auxílio podem oferecer. Os aspectos extraídos dos projetos similares foram a
avaliação de desempenho do aluno nos conteúdos usando um tipo de atividade como
referência e o sistema de aprendizado cooperativo através de indicação de outros alunos que
possam ajudar.
Na etapa de desenvolvimento, foi elaborado o projeto do sistema proposto, o qual foi
posteriormente implementado. As decisões tomadas no desenvolvimento do sistema
basearam-se nos estudos realizados e em boas práticas de desenvolvimento. Podem-se citar
como as decisões mais significativas:
68
A utilização da metodologia sócio-construtivista como base para um dos métodos
de auxílio oferecidos pelos agentes assistentes, uma vez que esta metodologia
proporciona maior interatividade entre os alunos;
A escolha do framework JADE como ferramenta para o desenvolvimento dos
agentes, devido à baixa curva de aprendizagem do mesmo, boa documentação
disponível e existência de casos anteriores de integração com o MOODLE;
A determinação do questionário como atividade de avaliação de desempenho do
aluno, já que ele pode demonstrar com exatidão o quanto foi compreendido de um
conteúdo específico;
A definição das duas formas de auxílio fornecidas pelo assistente, sendo elas a
indicação de recursos e a indicação de alunos que possam atuar como tutores de
um conteúdo. Estes dois serviços de auxílio visam promover a aprendizagem
cooperativa, defendida pelo sócio-construtivismo, e o autodidatismo do aluno;
A especificação de cinco tipos distintos de agente com o objetivo de delimitar os
grupos de responsabilidades existentes no sistema. O agente assistente, por
exemplo, possui a responsabilidade de auxiliar e interagir com o aluno, mas o
agente responsável por buscar recursos sobre determinado conteúdo é o agente
buscador;
A utilização de um bloco MOODLE para construção da interface de comunicação
entre o aluno e seu agente, já que este tipo de componente pode ser facilmente
inserido em qualquer curso e permite que o sistema desenvolvido possa ser
utilizado em outros ambientes MOODLE além do Educline;
O estabelecimento de uma forma de comunicação direta entre a interface gráfica e
o agente do assistente, utilizando web services SOAP. A implementação foi
realizada com um plugin do próprio JADE;
A integração com o projeto LOP2P (SANTIAGO, 2009), que permitiu ao agente
buscador realizar buscas de objetos de aprendizagem em repositórios externos ao
Educline, como complemento aos materiais existentes no próprio ambiente.
Ao término do desenvolvimento, o sistema foi implantado no AVA Educline, onde
teve suas funcionalidades testadas. Os testes permitiram a correção de pequenos problemas na
69
programação, mas constataram o correto funcionamento dos serviços providos pelos agentes,
que correspondem aos requisitos funcionais do sistema.
O sistema Erudio será cedido para Secretaria Municipal de Educação de Itajaí, e
poderá ser disponibilizado a todos que desejarem utilizá-lo ou aprimorá-lo. Considerando que
o ambiente Educline possui previsão para ser oficialmente lançado aos alunos de todas as
escolas da rede municipal no primeiro semestre de 2013, pretende-se submeter o Erudio a
novos testes na ocasião, com uma amostra maior de alunos. Com os resultados obtidos, e
recebendo um feedback positivo dos estudantes, será possível decidir se é ou não vantajoso
manter o sistema em funcionamento.
4.1 Trabalhos Futuros
Vários aspectos do sistema desenvolvido podem ser aprimorados ou complementados
com novas funcionalidades. Como propostas de trabalhos futuros, podem-se citar: (i)
aprimoramento dos agentes classificadores, através da incorporação de outras técnicas de
mineração de texto e da análise semântica para identificar palavras-chave equivalentes ou
relacionadas, melhorando a qualidade da classificação automática de questões; (ii) adição de
funcionalidades aos agentes gerentes, que podem ser utilizados para identificar dificuldades
recorrentes entre os alunos de diferentes cursos e assim tomar medidas de auxílio direcionadas
ao grupo.
70
REFERÊNCIAS BIBLIOGRÁFICAS
ALVES, João Roberto Moreira. Educação á Distância e as Novas Tecnologias de
Informação e Aprendizagem. 1998. Disponível em:
<http://www.engenheiro2001.org.br/programas/980201a1.htm>. Acesso em: 06 mar. 2012.
AZEVEDO, Wilson. Panorama atual da Educação á Distância no Brasil. 1999. Disponível
em: < http://www.escolanet.com.br/sala_leitura/txt_integral.html>. Acesso em: 06 mar. 2012.
CARDOSO, Olinda Nogueira Paes. Recuperação de informação. 2009. Disponível em:
<http://www.dcc.ufla.br/infocomp/artigos/v2. 1/art07.pdf> Acesso em: 28 maio 2012.
DRECHSLER, Mark. MOODLE structural overview. 2011. Disponível em:
<http://www.slideshare.net/mark.drechsler/moodle-structural-overview>Acesso em: 05 abr.
2012.
FIPA. The Foundation for Intelligent Physical Agents. 2012. Disponível em:
<http://www.fipa.org/> Acesso em: 22 abr. 2012.
ITAJAÍ (SC), Lei Nº 1523, de 28 de janeiro de 1977. Dispõe sobre a nova estrutura
administrativa da Prefeitura Municipal de Itajaí. Câmara Municipal, Itajaí, 1977.
ITAJAÍ (SC), Lei Complementar Nº 14, de 17 de dezembro de 2001. Modifica a estrutura
administrativa da Secretaria de Educação, e dá outras providências. Câmara Municipal,
Itajaí, 2001.
ITAJAÍ (SC), Lei Complementar Nº 36, de 22 de dezembro de 2003. Revoga a Lei
Complementar Nº 014 de 17 de dezembro de 2001, modifica a estrutura administrativa da
Secretaria Municipal de Educação, e dá outras providências. Câmara Municipal, Itajaí,
2003.
JADE. Jade Framework. 2012. Disponível em: <http://jade.tilab.com/> Acesso em: 21 abr.
2012.
JADE BOARD. Jade Web Services Integration Gateway (WSIG) Guide. 2012. Disponível
em: <http://jade.tilab.com/doc/tutorials/WSIG_Guide.pdf> Acesso em: 08 ago. 2012.
JASON. About Jason. 2012. Disponível em: <http://jason.sourceforge.net/Jason/Jason.html>
Acesso em: 21 abr. 2012.
KURC, Sheila. História da Ead. 2009. Disponível em:
< http://eadumalongatrajetoria.blogspot.com/2009/10/historia-da-ead.html>. Acesso em: 06
mar. 2012.
LÉVY, Pierre. O que é o virtual? São Paulo: Editora 34, 1996.
LIMA, Elidiani; INUZUKA, Marcelo Akira; MOTA, Luigi. Analisando os aspectos sócio-
construtivistas no ambiente virtual de aprendizagem MOODLE. 2012. Disponível em: <
http://pt.wikinourau.org/bin/view/Main/ArtigoMoodle> Acesso em: 27 mar. 2012.
71
LIN Fuhua; KINSHUK; LIU, Tzu-Chien; GRAF, Sabine; MCGREAL, Rory; SCUTELNICU,
Adrian. 2010. Integrating JADE agents into MOODLE. Disponível em:
<http://auspace.athabascau.ca/handle/2149/2605> Acesso em: 21 abr. 2012.
LITTO, F.; FORMIGA, M. Educação á distância: o estado da arte. São Paulo:
Pearson Education do Brasil, 2009.
MAES, P. Agents that reduce work and information overload. Communications of the
ACM, Vol 37, No. 7, pp.31-40, July 1994.
MENDONÇA, Anny Key de Souza; SOUTO-MAIOR, Cesar Duarte; PADILHA, Régis
Sangoi. Que tal planejar sua próxima viagem usando um sistema multiagente? 2007.
Disponível em: <http://www.convibra.com.br/2007/congresso/artigos/353.pdf> Acesso em:
27 maio 2012.
MOODLE. Developer documentation. 2012a. Disponível em: <http://docs.moodle.org/dev>
Acesso em: 05 abr. 2012.
MOODLE. Estatísticas MOODLE. 2012b. Disponível em: < http://moodle.org/stats>
Acesso em: 25 mar. 2012.
MOODLE. MOODLE 2.2 documentation. 2012c. Disponível em:
<http://docs.moodle.org/22 > Acesso em: 05 abr. 2012.
NISKIER, A. Educação à distância: a tecnologia da esperança. São Paulo: Loyola, 1999.
NUNES, Ingrid Oliveira de. Implementação do modelo e da arquitetura BDI. 2007.
Disponível em: <ftp://ftp.inf.puc-rio.br/pub/docs/techreports/07_33_nunes.pdf> Acesso em:
12 maio 2012.
NWANA, H. Software agents: an overview. Knowledge Engineering Review, Vol 11,
N. 3, pp. 1-40, September 1996.
RIBEIRO, João Pedro Accorsi; REATEGUI, Eliseo; BOFF, Elisa. Integrando um agente
pedagógico para recomendação de tutores a um sistema de gerência de cursos. 2007.
Disponível em: <http://www.cinted.ufrgs.br/ciclo9/artigos/7dJoaoPedro.pdf> Acesso em: 21
abr. 2012.
RUSSEL, Stuart Jonathan; NORVIG, Peter. Inteligência artificial. Rio de Janeiro: Elsevier,
2004.
RUSTICI SOFTWARE. SCORM explained. 2012. Disponível em:
<http://scorm.com/scorm-explained> Acesso em: 16 abr. 2012.
SANTIAGO, Rafael de. LOP2P: Arquitetura para compartilhamento de objetos de
aprendizagem entre instituições de ensino. 2009. Disponível em: <
http://siaibib01.univali.br/pdf/Rafael%20de%20Santiago%20Dissertacao.pdf> Acesso em: 28
maio 2012.
72
SANTOS, Edméa Oliveira. Ambientes virtuais de aprendizagem: por autorias livres,
plurais e gratuitas. 2003. Disponível em:
<http://www.comunidadesvirtuais.pro.br/hipertexto/home/ava.pdf> Acesso em: 06 mar. 2012.
VALENTE, José Armando. Informática na educação: instrucionismo x construcionismo.
Disponível em: <http://www.educacaopublica.rj.gov.br/biblioteca/tecnologia/0003.html>
Acesso em: 02 jun. 2012.
VYGOTSKY, L. S. Pensamento e linguagem. São Paulo: Martins Fontes, 1988.
WOOLDRIDGE, M.; JENNINGS, N. R. Intelligent agents: theory and practice, Vol 10.
Cambridge: Cambridge University Press, 1995.
WOOLDRIDGE, Michael J. An introduction to multiagent systems. New York: J. Wiley &
Sons, 2002.