autoexplc sistema tutor inteligente para auxÍlio … · obtenção do título de mestre em...
TRANSCRIPT
CLÁUDIO LUÍS VIEIRA OLIVEIRA
AUTOEXPLC SISTEMA TUTOR INTELIGENTE PARA AUXÍLIO AO
ENSINO DA LINGUAGEM “C” BASEADO NA APRENDIZAGEM POR AUTO-EXPLICAÇÃO DE
EXEMPLOS
PUC-CAMPINAS 2005
CLÁUDIO LUÍS VIEIRA OLIVEIRA
AUTOEXPLC SISTEMA TUTOR INTELIGENTE PARA AUXÍLIO AO
ENSINO DA LINGUAGEM “C” BASEADO NA APRENDIZAGEM POR AUTO-EXPLICAÇÃO DE
EXEMPLOS
Dissertação apresentada como exigência para obtenção do Título de Mestre em Sistemas de Computação, ao Programa de Pós-Graduação do Centro de Ciências Exatas, Ambientais e de Tecnologias, Pontifícia Universidade Católica de Campinas.
Orientador: Prof. Dr. Carlos Miguel Tobar Toledo
PUC-CAMPINAS 2005
Ficha Catalográfica Elaborada pelo Sistema de Bibliotecas e Informação – SBI – PUC-Campinas
t006.3 Oliveira, Cláudio Luís VieiraO48a AutoExplC: sistema tutor inteligente para auxílio ao ensino da linguagem “C” baseado na aprendizagem por auto-explicação de exemplos / Cláudio Luís Vieira Oliveira. - Campinas: PUC-Campinas, 2005. 107p. Orientador: Carlos Miguel Tobar Toledo. Dissertação (mestrado) – Pontifícia Universidade Católica de Campinas, Centro de Ciências Exatas, Ambientais e de Tecnologias, Pós-Graduação em Informática. Inclui apêndices e bibliografia.
1. Inteligência artificial – Aplicações educacionais. 2. Inteligência artificial – Processamento de dados. 3. Preceptores – Processamento de dados. 4. Ensino gerenciado por computador. 5. Ensino individualizado – Processamento de dados. 6. C (Linguagem de programação de computador) I. Tobar, Carlos Miguel. II. Pontifícia Universidade Católica de Campinas. Centro de Ciências Exatas, Ambientais e de Tecnologias. Pós-Graduação em Sistemas de Computação. III. Título.
i
Em memória dos meus pais, Manoel e
Maria Creyde, que sempre me
incentivaram e apoiaram na busca do
conhecimento.
ii
AGRADECIMENTOS
Ao Prof. Dr. Carlos Miguel Tobar Toledo,
Orientador e incentivador dos meus trabalhos de pós-graduação no Centro de Ciências Exatas e
Tecnológicas da Pontifícia Universidade Católica de Campinas, pela constante motivação, apoio,
atenção e amizade.
Aos Prof. Dr. Ricardo Luís de Freitas, Prof. Dr. Juan Manuel Adán Coello e Prof Dr. João Luís
Garcia Rosa,
Pelo estímulo e importantes sugestões.
iii
“E como, em toda a Galáxia, não descobriram
nada mais precioso do que a Mente,
incentivaram seu alvorecer por toda parte.
Tornaram-se lavradores nos campos de
estrelas; semearam e, vez por outra,
colheram.“
Arthur Charles Clarke
(1917-)
iv
RESUMO OLIVEIRA, C.L.V. AutoExplC - Sistema Tutor Inteligente para auxílio ao ensino da
Linguagem “C” baseado na aprendizagem por auto-explicação de exemplos. Campinas,
2005. 107f. Dissertação (Mestrado) – Curso de Pós-Graduação em Sistemas de
Computação, Pontifícia Universidade Católica de Campinas. Campinas, 2005.
Os Sistemas Tutores Inteligentes (STI) têm auxiliado estudantes em diversos domínios,
tais como geometria, química e programação. Esses domínios são considerados ideais,
porque podem ser facilmente representados e também porque o tipo de interação entre o
estudante e o STI pode ser limitado a um conjunto restrito de lexemas, símbolos e
números. A proposta desta dissertação consiste em explorar a tecnologia de sistemas
inteligentes no contexto do suporte a explicações em um STI, em que se usa a auto-
explicação de exemplos para auxiliar no aprendizado da linguagem de programação “C”,
mais especificamente para os níveis iniciais de aprendizagem, focando o processamento
da língua natural e a classificação das explicações dos alunos. O ambiente proposto
apresenta exemplos de programas, previamente elaborados pelo professor, e solicita ao
aluno a explicação de trechos de código-fonte. Utilizando técnicas de entendimento
aproximado da língua natural, o sistema tenta reconhecer o conteúdo da explicação
gerada pelo aluno e, em seguida, envia o resultado a um módulo que procura classificar
as explicações como corretas, incorretas ou incompletas em relação ao contexto da
atividade proposta e, a partir disso, traça a estratégia de ensino para as etapas
subseqüentes.
Termos de indexação: inteligência artificial – aplicações educacionais, inteligência
artificial – processamento de dados, preceptores – processamento de dados, ensino
gerenciado por computador, ensino individualizado – processamento de dados, C
(linguagem de programação de computador).
v
ABSTRACT OLIVEIRA, C.L.V. AutoExplC – An Intelligent Tutoring System to support “C” Language
learning through exploration of example self-explanation. Campinas, 2005. 107p. Thesis
(Master Degree) Post Graduation – Computer System, Pontifical Catholic University of
Campinas. Campinas, 2005.
Intelligent Tutoring Systems (ITS) have assisted students in several domains, such as
geometry, chemistry and programming. These knowledge areas are considered ideal,
because they can easily be represented and also because the type of interaction between
the student and the ITS can be limited to a restricted set of words, symbols and numbers.
The proposal of this thesis consists of exploring intelligent systems technology in the
context of supporting explanations in an ITS, that supports self-explanation of examples to
assist in the learning process of the “C” programming language for beginners. More
specifically, this work emphasizes natural language processing and the classification of
student’s explanations. The considered environment presents examples of programs,
previously elaborated by the teacher, and requests the student to explain pieces of source
code. Using techniques of approximate natural language understanding the system tries
to recognize the content of the explanation generated by the student and, after that, it
sends the result to a module that tries to classify the explanations as correct, incorrect or
incomplete according to the context of the proposed activity and, considering this, traces
the education strategy for the subsequent stages.
Index terms: artificial intelligence - educational applications, artificial intelligence - data
processing, tutors - data processing, computer aided learning, individual education - data
processing, C (computer programming language).
vi
SUMÁRIO
RESUMO .............................................................................................................. IV
ABSTRACT ........................................................................................................... V
LISTA DE FIGURAS........................................................................................... VIII
LISTA DE TABELAS............................................................................................ IX
1. INTRODUÇÃO....................................................................................................1
2. REFERENCIAL TEÓRICO .................................................................................4
2.1. Auto-Explicação e Aprendizagem Através de Exemplos ...........................5
2.2. Sistemas Tutores Inteligentes (STI) .............................................................7 2.2.1. Modelo do Domínio....................................................................................9 2.2.2. Modelo do Estudante.................................................................................9 2.2.3. Modelo do Tutor ........................................................................................9 2.2.4. Ambiente de Aprendizado .......................................................................11
2.3. Representação do Conhecimento ..............................................................11 2.3.1. Representação Baseada em Regras.......................................................12 2.3.2. Lógica ......................................................................................................13 2.3.3. Redes Semânticas...................................................................................14 2.3.4. Frames ....................................................................................................15 2.3.5. Raciocínio Baseado em Casos................................................................16 2.3.6. Redes Bayesianas...................................................................................18
2.4. Processamento da Língua Natural .............................................................20 2.4.1. Análise Léxica .........................................................................................22 2.4.2. Análise Sintática ......................................................................................23 2.4.3. Análise Semântica...................................................................................24 2.4.4. Análise Semântica Latente ......................................................................26
3. MODELO PROPOSTO .....................................................................................28
3.1. Trabalhos Relacionados..............................................................................29
3.2. Modelo para o STI ........................................................................................31
3.3. Escolha da Forma de Representação do Conhecimento .........................33
3.4. Definição das Rotinas para Entendimento Aproximado da Língua Natural..............................................................................................................................34
3.5. Implementação .............................................................................................36 3.5.1. Modelo do Domínio..................................................................................37
vii
3.5.2. Modelo do Estudante...............................................................................38 3.5.3. Interface Aluno-Engenho .........................................................................38 3.5.4. Engenho de Inferência.............................................................................38 3.5.5. Interface do Professor .............................................................................39
3.6. Funcionamento do STI Proposto................................................................40 3.6.1. Subsistema do Professor.........................................................................41 3.6.2. Subsistema do Aluno...............................................................................47
4. RESULTADOS .................................................................................................56
4.1. Avaliação Preliminar....................................................................................59
4.2. Avaliação Final .............................................................................................61
5. DISCUSSÃO.....................................................................................................63
5.1. Análise da Avaliação Preliminar .................................................................65
5.2. Análise da Avaliação Final ..........................................................................67 5.2.1 Análise das Respostas Erradas................................................................69 5.2.2. Avaliação das Respostas Incompletas ....................................................70 5.2.3. Avaliação das Respostas Corretas..........................................................73
6. CONCLUSÃO ...................................................................................................78
7. REFERÊNCIAS ................................................................................................82
APÊNDICES .........................................................................................................88
A. Estrutura das Relações..................................................................................89
B. Atividades Propostas para a Avaliação do STI............................................91
C. Explicações Utilizadas na Avaliação do STI ................................................93
viii
LISTA DE FIGURAS Figura 1: Modelo tradicional de um Sistema Tutor Inteligente ................................8
Figura 2: Escolha das táticas de ensino................................................................10
Figura 3: Proposta para o STI AutoExplC .............................................................32
Figura 4: Proposta para as rotinas para entendimento aproximado da língua
natural ............................................................................................................36
Figura 5: Diagrama entidade-relacionamento dos modelos do STI ......................41
Figura 6: Janela inicial do subsistema do professor..............................................42
Figura 7: Cadastro do Exemplo.............................................................................42
Figura 8: Cadastro da Atividade............................................................................43
Figura 9: Conexão com a aplicação do aluno .......................................................47
Figura 10: Janela principal da aplicação do aluno ................................................48
Figura 11: Nós da Rede Bayesiana ......................................................................52
Figura 12: Cadastro dos pesos dos componentes da atividade proposta.............72
Figura 13: Componentes da explicação e respectivos pesos ...............................73
ix
LISTA DE TABELAS Tabela 1: Armazenamento da estrutura “if-else” na relação Mapeador ............... 44
Tabela 2: Inclusão na relação Peso-Explicação ................................................... 46
Tabela 3: Extração dos radicais ............................................................................ 48
Tabela 4: Pré-etiquetagem dos radicais ............................................................... 49
Tabela 5: Resultado da pesquisa na relação Corpus ........................................... 50
Tabela 6: Mapeamento dos lexemas da explicação ............................................. 50
Tabela 7: Exemplo das faixas para classificação de uma explicação .................. 53
Tabela 8: Exemplo de um registro da relação Progresso ..................................... 54
Tabela 9: Avaliação Preliminar – Respostas Erradas ........................................... 59
Tabela 10: Problema da classificação de explicações sobre um único comando. 60
Tabela 11: Avaliação Final – Respostas Erradas ................................................. 61
Tabela 12: Exemplo da influência dos pesos dos nós .......................................... 64
Tabela 13: Algumas atividades propostas ............................................................ 66
Tabela 14: Etiquetagem dos lexemas que compõem a explicação ...................... 66
Tabela 15: Atuação do nó para identificação do contexto da explicação ............. 67
Tabela 16: Avaliação Final – Respostas Erradas do Nível 3 ................................ 69
Tabela 17: Explicação que foi classificada de forma equivocada ......................... 70
Tabela 18: Avaliação Final – Respostas Incompletas .......................................... 70
Tabela 19: Explicações incompletas classificadas como corretas ....................... 71
Tabela 20: Avaliação Final – Análise Corretas ..................................................... 73
Tabela 21: Explicações incorretamente classificadas pelo STI ............................ 74
Tabela 22: Continuação da Tabela 21 .................................................................. 75
Tabela 23: Continuação da Tabela 22 .................................................................. 76
Tabela 24: Síntese dos resultados obtidos na avaliação final em relação ao Nível 3 ...................................................................................................... 80
1. INTRODUÇÃO
2
A proposta desta dissertação consiste em explorar a tecnologia de
sistemas inteligentes no contexto do suporte a explicações em um Sistema Tutor
Inteligente (STI), em que se usa a auto-explicação de exemplos para auxiliar no
aprendizado da linguagem de programação “C”.A auto-explicação de exemplos
pode ser aplicada a domínios bem estruturados (SCHWORM; RENKL, 2002).
Esta proposta foca a sua aplicação no aprendizado de linguagens de
programação que, segundo Weber e colegas (1996), é considerada uma tarefa
estruturada e de grande complexidade, exigindo a presença quase constante de
um tutor, humano ou não, auxiliando e monitorando o aprendizado.
Conhecer uma linguagem de programação não é o mesmo que saber
programar. Ainda, segundo Weber e colegas (1996), o aprendizado de
programação deve incluir as seguintes habilidades: a) resolução de problemas; b)
conhecimento da sintaxe de uma determinada linguagem de programação; c)
aprendizado de lógica de programação; d) utilização de um ambiente de
programação, teste e depuração para os programas criados. No escopo deste
trabalho, auto-explicações permitem desenvolver as três primeiras habilidades.
Essas habilidades envolvem um certo grau de dificuldade. Porém,
existe um consenso que a maior dificuldade relaciona-se à habilidade de resolver
problemas dentro do contexto computacional, pois, mesmo que uma pessoa saiba
resolver muito bem um problema na vida real, por exemplo uma equação do
segundo grau, ela poderá encontrar grandes dificuldades em representá-lo
computacionalmente (WEBER et al, 1996).
A grande vantagem da aplicação da estratégia de auto-explicação de
exemplos dentro do domínio do aprendizado de programação está justamente
3
fundamentada sobre a resolução de problemas para a aquisição de habilidades
meta-cognitivas (CHI et al, 1989).
O STI desenvolvido auxilia no ensino da linguagem de programação
“C”, mais especificamente para os níveis iniciais de aprendizagem, focando o
processamento da língua natural e a classificação das explicações dos alunos. O
ambiente apresenta exemplos de programas, elaborados pelo professor, e solicita
ao aluno a explicação dos mesmos. O sistema tenta reconhecer respostas
corretas, incorretas ou incompletas e, a partir das mesmas, traça a estratégia de
aprendizado para as etapas subseqüentes.
Esta dissertação encontra-se organizada do seguinte modo: o Capítulo
2 apresenta os fundamentos teóricos estudados e que constituem os
fundamentos para a definição do STI objeto do trabalho. No Capítulo 3 é
apresentado o modelo proposto para o STI, precedido pela apresentação de
alguns tutores que influenciaram essa proposta.
O Capítulo 4 trata do processo adotado para realizar a avaliação da
implementação do STI proposto, considerando os aspectos de velocidade de
execução e reconhecimento adequado das explicações, enquanto o Capítulo 5
aborda a discussão dos resultados obtidos.
A conclusão da presente dissertação é o objeto do Capitulo 6, no qual
são abordadas algumas perspectivas para futuros trabalhos.
2. REFERENCIAL TEÓRICO
5
O referencial teórico desta dissertação consiste na revisão bibliografia,
que para fins de estudo, encontra-se subdividida nos seguintes tópicos: auto-
explicação, sistemas tutores inteligentes, representação do conhecimento e
entendimento de língua natural.
2.1. Auto-Explicação e Aprendizagem Através de Exemplos
Chi e colegas (1989, 1994) consideram que a auto-explicação é
bastante positiva para o aprendizado, pois:
• O aprendizado é um processo construtivo, no qual o aluno converte
palavras e exemplos, gerados por um professor ou apresentados
através de um texto, em habilidades, através da resolução de
problemas.
• A explicação é um mecanismo de estudo que permite ao aluno criar
inferências e explicar as condições e conseqüências de cada passo de
um exemplo, além de tornar possível, a aplicação de princípios e
definições dos conceitos empregados com o objetivo de justificá-los.
• O aprendizado envolve a integração de novas informações ao
conhecimento já existente. Gerar explicações a si mesmo (auto-
explicação) facilita este processo de integração.
• A maior parte dos alunos escreve novos programas por analogia a
programas exemplo. O sucesso desta prática está intimamente
relacionado ao grau de entendimento que estes alunos obtiveram do
exemplo. O aprendizado e o entendimento do exemplo é obtido através
das explicações que os alunos geram enquanto estudam. A auto-
6
explicação é importante e necessária, dentro deste processo, porque
muitos exemplos apresentam seqüências de ações não explicadas.
Como conseqüência, motivar o aluno para produzir explicações
espontâneas sobre um tópico abordado produzirá um melhor aprendizado em
relação à leitura de um texto ou mesmo a uma explicação de terceiros. Outro
benefício deste método está relacionado ao encorajamento dos processos
cognitivos que estimulam o aprendizado (CONATI; VANLEHN, 1999).
Os processos de aprendizado são freqüentemente considerados em
termos de compreensão, aquisição de habilidades, ou ambos. No caso da
compreensão, a informação declarativa que deverá ser entendida está
relacionada a algum conhecimento que já está armazenado e organizado na
memória. Desta forma, podemos entender que a compreensão consiste na
instanciação de um conhecimento existente (CHI et al, 1994).
O entendimento pleno só é obtido quando o aluno é capaz de
processar uma porção não explicada de um exemplo, através da formulação de
conclusões e a criação de inferências a partir da informação apresentada. Para
fazer isso, o aluno precisa gerar explicações.
O aprendizado através de exemplos é considerado um método natural
e comum para a obtenção de novos conhecimentos. Freqüentemente,
professores recorrem a exemplos para ilustrar um tópico abordado de forma a
permitir ao aluno fixar o conhecimento transmitido (CONATI et al, 1997).
Porém, o emprego de exemplos para o aprendizado não garante
eficácia. O grau de eficácia está fortemente associado à maneira que o estudante
explica a si mesmo os passos para a solução do exemplo, ou em outras palavras,
o quanto o estudante aplica a habilidade meta-cognitiva da auto-explicação.
7
2.2. Sistemas Tutores Inteligentes (STI)
O termo “Sistema Tutor Inteligente” é aplicado a programas que são
projetados para o ensino e que fazem uso de técnicas de Inteligência Artificial
(FREEDMAN et al, 2000). O objetivo principal destes programas consiste em
complementar ou, até mesmo, substituir um tutor humano, com a vantagem de
acompanhar o aluno em cada passo de aprendizado. Informações sobre as
dificuldades específicas ou a velocidade de aprendizagem compõem um modelo
de usuário, que reflete o conhecimento adquirido e a evolução frente ao
entendimento do domínio que está sendo estudado.
Os STIs podem ser considerados uma evolução dos tradicionais
sistemas CAI (Computer Aided Instruction), mas que, ao contrário desses, utilizam
técnicas de Inteligência Artificial e procuram gerar uma experiência individualizada
de aprendizagem para o estudante, simulando as interações entre um professor e
um aluno.
O processo ensino-aprendizado apresenta grande dependência da
interação e da adaptação, que são características típicas da inteligência humana,
apresentando grandes dificuldades e desafios na implementação de soluções
computacionais inteligentes. A maior parte dos projetos existentes não
implementam todas as funcionalidades propostas pelos trabalhos teóricos, sendo,
por essas razões, justificado investir no estudo tanto das técnicas de
planejamento como também de implementação desses sistemas (LUSTOSA;
ALVARENGA, 2004).
De acordo com Hall e Wood (1990), os STIs consistem de uma
composição interdisciplinar, sendo que o objetivo primário destes sistemas,
consiste na modelagem e na representação do conhecimento de um especialista
8
humano, de modo a auxiliar a aprendizado do estudante através de processos
personalizados e interativos. Dentro do ambiente de um STI, procura-se não
apenas ensinar, mas maneiras de como ensinar. “Os STIs têm sido apresentados
como altamente eficientes para a melhora do desempenho e motivação dos
estudantes” (LIMA; ROSATELLI, 2003).
É importante salientar, neste momento, que a utilização dos STIs
trouxeram à tona algumas questões pedagógicas. As tecnologias que permitem
automatizar métodos tradicionais de ensino e aprendizagem têm também
auxiliado na criação de novos métodos além de redefinir metas educacionais
(MCARTHUR et al, 1993). Dentre estes novos métodos, é possível citar vários
aspectos do trabalho colaborativo e o aprendizado através de exemplos (LIMA;
ROSATELLI, 2003).
Um modelo tradicional de um STI apresenta quatro componentes: o
modelo do domínio, o modelo do estudante, o modelo do tutor e um ambiente de
aprendizado (FREEDMAN et al, 2000), conforme apresentado na Figura 1 e
discutido em seguida.
Figura 1: Modelo tradicional de um Sistema Tutor Inteligente
(FREEDMAN et al, 2000)
Modelo do domínio
Modelo do tutor
Modelo do estudante
Ambiente de aprendizado
Aluno
9
2.2.1. Modelo do Domínio
O modelo do domínio possui a representação do conhecimento de um
especialista na área sob estudo na qual o sistema irá atuar. É composto por
conhecimentos declarativos e procedimentais e, apresenta-se organizado na
forma de listas, diagramas de estruturas ou regras.
O conhecimento declarativo define os termos do domínio, seus
atributos e o relacionamento entre os termos. O conhecimento procedimental
consiste de argumentos ou regras que serão utilizados na resolução dos
problemas que são apresentados ao estudante.
2.2.2. Modelo do Estudante
O modelo do estudante representa o grau de conhecimento do mesmo,
seus acertos, erros e dificuldades. O modelo do estudante deve ser capaz de
definir o nível de conhecimento do aluno a qualquer momento dentro do sistema.
Este modelo também pode ser composto por conhecimentos declarativos e
procedimentais.
2.2.3. Modelo do Tutor
O modelo do tutor permite a simulação das decisões de um professor,
um processo referente a intervenções pedagógicas e, posteriormente, permite a
geração das instruções apropriadas baseando-se nas diferenças entre o modelo
do domínio e o modelo do estudante. O modelo do tutor possibilita acompanhar a
cobertura dos tópicos do domínio e analisa o entendimento do aluno através de
avaliações.
10
A preocupação neste modelo não é a representação do conhecimento
global, mas como um indivíduo representa seu próprio conhecimento através do
uso de suas habilidades dentro do domínio.
Um fator chave no projeto de um STI consiste na correta definição das
estratégias e táticas de ensino. As estratégias de ensino podem ser definidas
como planos que definem as formas de ensino e aprendizagem do aluno.
Uma estratégia de ensino é composta por um conjunto de táticas de
ensino, as quais consistem no trabalho que deverá ser desenvolvido pelo aluno
para obter um determinado conhecimento.
Durante a interação entre o aluno e o STI podem ser utilizadas
diferentes estratégias de ensino com o objetivo de auxiliar o aluno a refletir e
analisar os resultados oriundos de sua tomada de decisão.
A escolha do procedimento a ser adotado, em um determinado instante
da interação, deverá considerar as informações contidas no módulo do aluno.
Após a aplicação de uma estratégia, por parte do STI, tem-se então o modelo de
aluno modificado, uma vez que, o estado cognitivo percebido pode ter mudado.
Durante a interação, o STI considera que a resolução de cada uma das atividades
segue uma determinada seqüência lógica de etapas que devem ser cumpridas de
maneira correta. Os recursos disponibilizados em cada etapa também podem ser
considerados.
Figura 2: Escolha das táticas de ensino
(Konzen; Frozza, 1999)
Escolha do modelo do aluno
Escolha da estratégia de ensino
Escolha das táticas
de ensino
11
Conforme ilustrado pela Figura 2, as táticas de ensino que poderão ser
aplicadas a determinado processo de aprendizagem do aluno são definidas após
a escolha do modelo do aluno e da estratégia de ensino (KONZEN; FROZZA,
1999).
2.2.4. Ambiente de Aprendizado
No caso do STI ser generativo (WOOLF et al, 2002), este STI
deve ter a capacidade de analisar o processo atual de
aquisição do conhecimento e, baseado nesta análise, gerar conclusões e
instruções que poderão ser responsáveis pela redução das discrepâncias entre o
modelo do domínio e o modelo do estudante. Este tipo de sistema é
supostamente “inteligente” devido ao seu ambiente de aprendizado, que possui a
capacidade de reagir de forma flexível e adaptativa ao processo de aquisição do
conhecimento.
A interface do ambiente de aprendizado é responsável pela troca de
informações entre o sistema, o instrutor e o aluno. Deve ser capaz de mostrar
informações coerentes com o nível de aprendizado do aluno e manter a coerência
nas explicações apresentadas sobre o domínio que está sendo estudado.
2.3. Representação do Conhecimento
Os STIs estão baseados na forma que os especialistas humanos
resolvem os problemas, ou seja, a partir do conhecimento do domínio da
aplicação. Isto traz a necessidade de representar o conhecimento do domínio.
Há duas abordagens distintas para a representação do conhecimento
(SRIRAM, 1997):
12
a) Representação declarativa - o conhecimento é especificado, mas as
operações para sua utilização não são fornecidas;
b) Representação procedimental - as operações de controle
necessárias ao uso do conhecimento estão presentes no próprio
conhecimento.
Algumas das principais técnicas conhecidas para a representação do
conhecimento dentro de um STI são: Representação Baseada em Regras,
Lógica, Redes Semânticas, Frames, Raciocínio Baseado em Casos e Redes
Bayesianas.
2.3.1. Representação Baseada em Regras
A representação baseada em regras é a maneira mais ampla e
originalmente utilizada na Inteligência Artificial para representação do
conhecimento. Basicamente, consiste na representação do conhecimento do
domínio através de um conjunto bem definido de regras, também denominadas
regras de produção. As regras de produção podem ser formadas tanto de
conhecimento declarativo (fatos), que é utilizado para representar o conhecimento
sobre os relacionamentos no domínio do problema, como de conhecimento
procedimental (heurísticas), que é o conhecimento sobre como solucionar o
problema usando o conteúdo das regras, definindo assim uma base de
conhecimento para um sistema baseado em regras.
Cada regra é dada através da forma geral: se <condições> então
<ações>, onde:
13
• <condições>: podem ser simples ou compostas, quando compostas
são conectadas através dos conectivos lógicos para realizar a
conjunção ou a disjunção.
• <ações>: consistem nas ações que serão consideradas, caso o
resultado da avaliação das <condições> seja verdadeiro.
2.3.2. Lógica
A lógica consiste em um sistema formal definido por regras de
formação e regras de inferência que, em sua origem, tinha como principal objetivo
formalizar a semântica da língua natural. Sendo a lógica proposicional, também
conhecida por lógica booleana, a mais tradicionalmente utilizada. Na lógica
proposicional, os símbolos representam os fatos e é possível combiná-los através
de operadores lógicos ou conectivos. Desta forma, pode-se formar sentenças
complexas e facilmente representar fatos do mundo real através de proposições
lógicas. Outra lógica empregada é a de predicados que possibilita expressar
propriedades gerais ou específicas quando utilizados os quantificadores universal
e existencial. A programação lógica ganhou aceitação na comunidade de
pesquisadores da Inteligência Artificial, devido à sua elegância, simplicidade e
perfeita base matemática (SRIRAM, 1997).
Uma importante motivação que justifica o uso da lógica matemática é
que, usando declarações lógicas como meio de armazenar conhecimentos, se
obtém um mecanismo formal para realizar inferências sobre o conhecimento
expresso. É importante salientar que não apenas as lógicas proposicional e de
predicados são utilizadas para representar conhecimento em STIs, outras mais
14
diversas também o são, tais como a lógica modal, a lógica das probabilidades e a
lógica nebulosa (fuzzy).
2.3.3. Redes Semânticas
Uma rede semântica consiste de um conjunto de nós conectados por
uma série de arcos que permitem representar conhecimento. Os nós em geral
representam objetos e os arcos, as relações binárias entre esses objetos. Mas os
nós também podem ser utilizados para representar outras entidades, de acordo
com o contexto do domínio do problema. Um dos atrativos, por trás desta
representação, é que o significado de um conceito vem do modo como ele é
conectado a outros conceitos, para formar o conhecimento.
As redes semânticas estão fundamentadas sobre um modelo
computacional da memória humana denominada memória associativa, no qual é
possível explicar diversos resultados experimentais sobre o comportamento da
memória humana, como, por exemplo, o fato de que o reconhecimento de objetos
que pertencem a classes mais numerosas toma mais tempo do que o
reconhecimento dos pertencentes a classes menos numerosas (SRIRAM, 1997).
Os nós encontrados nas redes semânticas, geralmente, estão
classificados em: nó individual que é uma instância particular de uma classe, onde
a classe pode ser definida como uma descrição de um ou mais objetos similares;
ou nó genérico que define uma classe de objetos similares.
Os relacionamentos comumente usados entre os nós em uma base de
conhecimento são:
• Generalização: envolve o agrupamento de um conjunto de nós
genéricos para formar um outro nó. O processo inverso da
15
generalização é denominado de especialização e denotada por uma
ligação é-um;
• Classificação: envolve o agrupamento de um conjunto de nós
individuais em um nó genérico. O processo inverso da classificação é
denominado de instanciação. A classificação é representada por uma
relação é-um;
• Agregação ou composição envolve a construção de um objeto a
partir de suas partes constituintes. Na literatura técnica sobre
orientação a objetos, também é conhecida pela denominação todo-
parte.
Um mecanismo de herança simples ou múltipla é obtido através dos
relacionamentos é-um e pode ser considerado como uma das características mais
fortes das redes semânticas, possibilitando que propriedades de um nó sejam
especificadas apenas uma vez, no mais alto nível da hierarquia de conceitos,
sendo herdados por todos os conceitos derivados.
2.3.4. Frames
A representação de conhecimento através de frames, proposta por
Minsky (1974), possibilita a modelagem e compreensão de linguagem natural. O
conceito de frames também está presente na origem das idéias que levaram às
linguagens de programação orientadas a objetos, bem como, na generalização
desta representação para a representação denominada script.
Em geral, um frame é uma coleção de atributos, chamados de slots, e
valores, que descrevem alguma entidade do mundo (RICH; KNIGHT, 1993). Os
frames integram conhecimento declarativo sobre objetos e eventos e
16
conhecimento procedimental sobre como recuperar informações ou calcular
valores. Os atributos também apresentam propriedades que dizem respeito ao
tipo de valores e às restrições de número que podem ser associadas a cada
atributo.
Assim como nas redes semânticas, uma das características nos frames
é a possibilidade de que sejam criados novos subtipos de objetos que herdem
todos as propriedades da classe original. Essa herança é bastante usada tanto
para a representação do conhecimento como para a utilização de mecanismos de
inferência.
Um slot de relação é utilizado para ligar dois frames. A relação e sua
herança associada podem ser definidas na maioria das linguagens baseadas em
frame, sendo que as especificações de herança definem quanta informação é
permitida ser herdada de um frame para outro.
2.3.5. Raciocínio Baseado em Casos
O raciocínio baseado em casos (RBC) está fundamentado sobre a
proposta de utilizar experiências passadas como base para lidar com novas
situações similares, além de combinar as vantagens da recuperação da
informação e do raciocínio baseado em regras (KOLODNER, 1993). Esta
abordagem parece ser intuitiva: quando uma nova situação ocorre, procura-se,
adotando um eficaz mecanismo de recuperação, utilizar algo que já foi utilizado
com sucesso. Sendo que, soluções utilizadas em situações similares podem
ajudar na solução desta nova situação. Por outro lado, o RBC pode funcionar
também de maneira inversa, ou seja, a partir de contra-exemplos. Neste caso, em
17
uma nova situação, devem-se descartar as soluções utilizadas no passado e que
resultaram em insucessos.
A principal parte do conhecimento nos sistemas baseados em RBC
está representada através de seus casos. Um caso pode ser definido como a
abstração de uma experiência descrita em termos de seu conteúdo e contexto,
podendo assumir deferentes formas de representação. O conhecimento neste
contexto pode ser interpretado como sendo um conjunto de métodos que
modelam um conhecimento especializado de modo de torná-lo disponível em um
sistema inteligente.
Apesar de um sistema RBC ser extremamente dependente da estrutura
e do conteúdo de sua base de casos, seu conhecimento não está presente
apenas nos seus casos, mas também nas etapas de desenvolvimento. Estas
etapas são:
• Representação dos casos - os casos devem manter o conhecimento
de eventos ocorridos em situações passadas. De acordo com Kolodner
(1993) os casos são formados por três elementos principais - a
descrição do caso, o caso em si e o estado posterior do domínio após a
aplicação da solução;
• Indexação - consiste em um problema central em RBC e envolve a
determinação dos tipos de índices que serão utilizados na etapa de
recuperação;
• Recuperação dos casos - uma vez definido o problema, esta etapa
realiza a busca na base de casos e seleciona quais casos podem ser
aproveitados para a solução do problema. Este processo é executado
18
por algoritmos que selecionam casos da base que apresentam um
determinado grau de similaridade com o caso proposto;
• Adaptação - o tipo principal de conhecimento usado durante a
solução de um problema é aquele fornecido pelo conhecimento
específico contido nos casos. Porém, existem situações em que este
conhecimento não é suficiente ou apropriado para atender os requisitos
da aplicação. Quanto isto ocorre, são utilizados conhecimentos de
domínio, os quais podem contribuir para a identificação de
dependências entre certas características de um caso e auxiliar na
inferência de características adicionais;
• Aprendizagem - novos casos ou casos adaptados podem ser
adicionados à base de casos.
O raciocínio baseado em casos pode ser aplicado em várias tarefas de
raciocínio, tais como: propor soluções para novos problemas, antecipar, evitar e
explicar falhas em soluções propostas, adequar ou retificar soluções propostas.
2.3.6. Redes Bayesianas
As Redes Bayesianas são um modelo de representação do
conhecimento incerto, baseado nos conceitos da teoria da Probabilidade
Bayesiana, proposta pelo Reverendo Thomas Bayes em 1763. O conhecimento
incerto é aquele que apresenta deficiências. Em determinado momento, os dados
permitem a obtenção de uma representação não exata, parcial ou aproximada da
realidade (BHATNAGAR; KANAL, 1986).
É importante observar que o modelo baseia-se em probabilidades
prévias e mais algumas informações com um certo nível de incerteza, para
19
representar o conhecimento. Um modelo totalmente incerto não seria de grande
utilidade e não teria ponto de partida para a manipulação de suas situações e a
geração de novas representações. A representação da Rede Bayesiana é feita
através de um grafo direcionado acíclico no qual os nós representam variáveis de
um domínio e os arcos representam a dependência condicional ou informativa
entre as variáveis (JENSEN, 2001). A dependência é representada através de
probabilidades, associadas a cada grupo de nós pais e filhos da Rede Bayesiana
(RUSSEL; NORVIG, 1995).
O elemento primário de uma linguagem de probabilidade é o evento.
Podemos entender um evento como um estado de alguma parte de nosso mundo
em um determinado intervalo de tempo (SIVIA, 1996).
Dentro de uma Rede Bayesiana, o processo de aprendizado é o
seguinte: a) o conhecimento de um conjunto de especialistas é representado em
uma Rede Bayesiana, como é feito na construção de um sistema especialista
probabilístico; b) um banco de dados é utilizado para atualizar este conhecimento,
gerando uma ou mais novas Redes Bayesianas. O resultado inclui um
refinamento do conhecimento dos especialistas originais e, em algumas ocasiões,
a identificação de novas distinções e relacionamentos. Esta abordagem é robusta
a erros no conhecimento do especialista, mesmo quando este conhecimento é
incompleto ou não confiável, permitindo seu uso para melhorar o processo de
aprendizagem (HECKERMAN, 1995).
O processo de treinamento de uma Rede Bayesiana é similar ao
utilizado nas redes neurais (HECKERMAN, 1995), porém apresenta duas
vantagens: a) é extremamente simples colocar o conhecimento de um
especialista em uma Rede Bayesiana e utilizá-lo para aumentar a eficiência e
20
precisão do aprendizado; b) os nós e arcos em uma Rede Bayesiana
freqüentemente correspondem a distinções reconhecíveis e relacionamentos
causais. Como conseqüência, é mais simples interpretar e entender o
conhecimento codificado na representação.
2.4. Processamento da Língua Natural
A capacidade de processamento de uma língua natural permite que os
seres humanos comuniquem-se com os computadores da forma mais simples
possível, utilizando uma língua com a qual já estão habituados. Evitando, deste
modo, a necessidade de adaptação a formas inusitadas de interação, ou mesmo
o aprendizado de uma língua artificial, cuja sintaxe costuma ser de difícil
aprendizado e domínio.
A comunicação entre pessoas e máquinas é uma área que tem
motivado uma série de pesquisas. O objetivo final é permitir que usuário e
equipamento possam se comunicar através de uma língua humana. Muitos
autores de ficção científica descrevem cenários no futuro nos quais, por meio de
uma simples conversa, as pessoas sejam capazes de explicar a tarefa que
querem que seja executada e o computador seja capaz de executá-la. Estudos
apontam para a possibilidade futura da existência de computadores com
capacidade de compreensão da língua natural possibilitando, por exemplo, o
processamento dos comandos expressos em linguagem (escrita ou falada) pelos
usuários finais. Outra perspectiva para o futuro mostra que o desenvolvimento de
modelos computacionais da língua natural permitirá um maior processamento de
informações, visto que a maior parte do conhecimento humano está registrado na
forma lingüística (RICH; KNIGHT, 1993).
21
O caráter interdisciplinar do processamento da língua natural ilustra o
nível de complexidade normalmente requerido das abordagens desenvolvidas, as
quais apresentam conceitos de inteligência artificial, teoria da computação,
compiladores, lingüística computacional e de outras disciplinas.
Basicamente, as aplicações dos sistemas que tratam a língua natural
podem ser divididas em duas classes: aplicações baseadas em texto e aplicações
baseadas em diálogos. Aplicações baseadas em texto são sistemas que
procuram documentos específicos dentro de uma base de dados específica.
Pode-se citar alguns exemplos: a tarefa de localizar livros relevantes em uma
biblioteca; sistemas que realizam a tradução de documentos e aplicações que
permitem sumarizar um determinado documento.
Dentro das aplicações baseadas em diálogos, é possível citar os STIs,
entre outros sistemas, que interpretam e respondem aos comandos expressos em
uma língua natural qualquer, escrita ou falada.
Para um sistema ser considerado processador da língua natural duas
condições devem ser satisfeitas:
• Um subconjunto de entrada e/ou saída do sistema é codificado em
uma língua natural;
• O processamento da entrada e/ou a geração da saída é baseada no
conhecimento sobre aspectos morfológicos, sintáticos, semânticos de
uma língua natural.
Observa-se, principalmente com a segunda condição, a exigência da
interpretação do conteúdo de uma sentença, sendo que esta condição não é
satisfeita nos sistemas que processam a língua natural puramente como cadeias
de caracteres como por exemplo, editores de texto ou pacotes estatísticos.
22
Para um computador realizar o processamento de uma língua natural
inicialmente deve-se dividir essa língua em seus elementos básicos.
Um lexema ou palavra é uma entrada individual em um léxico. Pode
ser entendido como um conjunto particular de ortografia e fonologia que possui
uma forma de representação simbólica do conhecimento. O léxico é um conjunto
finito de lexemas, sendo o componente mais extenso da língua.
Dentro deste contexto, os lexemas e seus respectivos significados são
importantes quando conseguem prover as informações necessárias para obter
representações significativas de sentenças inteiras. Esta abordagem é motivada
pelo fato de que os lexemas, por si só, não se referem ao mundo, não podem ser
determinados verdadeiros ou falsos, literais ou figurativos. Estes atributos apenas
podem ser aplicados a sentenças e contribuem, de forma simplória, ao conceito
de que o léxico é apenas uma relação de fragmentos simbólicos sem nenhuma
estrutura sistemática.
Para que um sistema computacional interprete uma sentença em
língua natural, é necessário manter informações morfológicas, sintáticas e
semânticas, armazenadas em um dicionário, juntamente com as palavras que o
sistema compreende. As etapas do processamento da língua natural estão
discriminadas a seguir (JURAFSKY; MARTIN, 2000) (RICH; KNIGHT, 1993).
2.4.1. Análise Léxica
O analisador léxico identifica lexemas ou expressões isoladas em uma
sentença, sendo este processo auxiliado por delimitadores, tais como símbolos
para pontuação e espaços em branco. Os lexemas identificados são classificados
23
de acordo com seu tipo de uso ou, em língua natural, dentro de uma categoria
gramatical.
Neste contexto, uma instância de um lexema dentro de uma sentença
gramaticalmente válida pode ser substituída por outra do mesmo tipo,
configurando uma sentença ainda válida, por exemplo: substantivos, pronomes e
verbos entre outros. Dentro de um mesmo tipo de lexema, existem grupos de
regras que caracterizam o comportamento de um subconjunto de vocábulos da
língua, por exemplo: formação do plural de substantivos terminados em "ão" e
flexões dos verbos regulares terminados em "ar" dentre outros. Assim, a
morfologia objetiva classificar os lexemas quanto à sua estrutura, forma, flexão e
classificação (JURAFSKY; MARTIN, 2000).
O emprego de um analisador léxico é fundamental para a compreensão
de uma frase, pois para formar uma estrutura coerente de uma sentença, é
necessário compreender o significado de cada um dos lexemas componentes
(RICH; KNIGHT, 1993).
2.4.2. Análise Sintática
O conceito de análise sintática está intimamente relacionado ao
conceito de gramática, que pode ser definido como um conjunto de regras que
expressam os modos que os símbolos de determinada língua podem ser
agrupados e ordenados. Através da gramática da língua a ser analisada e das
informações do analisador léxico, o analisador sintático procura construir árvores
de derivação para cada sentença, mostrando como os lexemas estão
relacionados entre si.
24
Durante a construção da árvore de derivação, é verificada a adequação
das seqüências de lexemas às regras de construção impostas pela língua, na
composição de frases, períodos ou orações. Dentre estas regras, pode-se citar a
concordância e a regência nominal e/ou verbal, bem como o posicionamento de
termos na frase. Um termo corresponde a um elemento de informação (lexema ou
expressão), sendo tratado como unidade funcional da oração, participando da
estrutura como um de seus constituintes que são denominados sintagmas.
A análise sintática de uma oração em português deve levar em conta
os seguintes sintagmas: termos essenciais (sujeito e predicado), termos
integrantes (complementos verbal e nominal) e termos acessórios (adjunto
adverbial, adjunto adnominal e aposto). A análise do período, por sua vez, deve
considerar o tipo de período (simples ou composto), sua composição (por
subordinação, por coordenação) e a classificação das orações (absoluta,
principal, coordenada ou subordinada).
Nos sistemas de processamento de língua natural, o maior problema é
a transformação de uma frase potencialmente ambígua em uma não ambígua, a
qual será utilizada pelo sistema. Esta transformação é conhecida como parsing.
2.4.3. Análise Semântica
A semântica pode ser definida como o estudo do sistema de
significados de uma língua. A lexema “significado” possui vários sentidos e as
abordagens semânticas podem variar muito. Uma delas estabelece que o
significado é a relação entre a linguagem e o mundo externo, sentido referencial
ou denotativo, e que a semântica investiga a relação entre as palavras e os
conceitos que as mesmas simbolizam. Outra abordagem está fundamentada no
25
estado mental do falante, refletindo um espectro de matizes pessoais e
emocionais, ou seja, sentido afetivo ou conotativo. Outra ainda refere-se ao
contexto social em que a língua é usada, do qual deriva parte desse significado,
conhecida com sentido contextual. Uma quarta abordagem refere-se às relações
sensoriais que conectam palavras e sintagmas, pelas quais sabe-se, por exemplo,
que algumas palavras têm o "mesmo" significado, por exemplo, carro e
automóvel. Além de outras que têm significado "oposto", por exemplo casado e
solteiro. Outros lexemas possuem um significado inerente, como o caso do gato,
que está incluso entre os animais. Em termos lingüísticos, é útil estabelecer a
distinção entre significado estrutural, cuja forma deriva de sua posição e função
no sistema gramatical da língua.
Em termos computacionais, a análise semântica pode ser entendida
como um processo no qual a representação do conhecimento é composta e
atribuída a entradas lingüísticas. A criação da representação do conhecimento, de
forma rica e precisa, obrigatoriamente envolve uma grande variedade de fontes
de conhecimento e técnicas de inferência. Neste contexto, as fontes de
conhecimento tipicamente adotadas estão relacionadas aos significados das
palavras. Os significados são associados às estruturas gramáticas,
conhecimentos sobre a estrutura da língua, conhecimentos sobre o contexto no
qual a frase está inserida e um senso comum sobre o tópico abordado.
A compreensão da relação entre as palavras é tão importante quanto a
compreensão das próprias palavras. Enfoques formais para a semântica
gramatical tentam descrever o sentido de uma frase mediante a tradução de sua
estrutura sintática para uma fórmula lógica-semântica. Como não existe uma
26
correspondência imediata e biunívoca entre sintaxe e semântica, uma mesma
estrutura sintática pode dar origem a diferentes representações semânticas.
2.4.4. Análise Semântica Latente
A adoção da Análise Semântica Latente permite capturar a ocorrência
semântica latente da informação, a partir da localização de palavras similares em
um contexto similar existente dentro de um corpus.
A Análise Semântica Latente foi desenvolvida originalmente como um
método de recuperação de informação, ou seja, permite selecionar de uma
grande base de dados um subconjunto de textos que combinam com a
especificação da busca (WIEMER-HASTINGS et al, 1999). A partir de
semelhanças das palavras-chave especificadas na busca, são selecionados os
textos que apresentam o número mais elevado destas semelhanças. Outra
característica da Análise Semântica Latente consiste na sua incapacidade de
reconhecer sinônimos ou sentidos alternativos para as palavras-chave.
A Análise Semântica Latente usa uma técnica estatística chamada de
decomposição singular do valor, para reduzir uma matriz de co-ocorrência dos
termos versus documentos a um conjunto de três matrizes muito menores, que
descrevem um espaço semântico N-dimensional. A primeira dessas três matrizes
resultantes especifica o vetor N-dimensional para cada um dos termos. A segunda
corresponde aos vetores para os documentos. E a terceira determina a
importância relativa de cada uma das dimensões de N. A relevância funcional
desta técnica estabelece que uma representação reduzida reproduz da melhor
maneira os dados originais e deve generalizar exemplos similares de palavras,
que ocorrem em um contexto similar. Isto resulta em uma representação onde os
27
termos similares e seus originais têm vetores de similaridade na distância N-
dimensional do espaço (LANDAUER, 2002).
3. MODELO PROPOSTO
29
STIs freqüentemente apresentam problemas aos alunos e verificam a
solução passo a passo, podendo ainda apresentar dicas sensíveis ao contexto
para cada passo da resolução. Porém, esses tutores não solicitam aos alunos
explicações ou justificativas sobre os passos executados para a solução, ao
contrário dos tutores humanos que procuram encorajar os alunos a raciocinar
sobre os passos executados na solução de um determinado problema. Da mesma
forma, a auto-explicação possui o potencial de ampliar o conhecimento do aluno
sobre o domínio, resultando na obtenção de um conhecimento que permite
generalizar melhor em novas situações. Porém, para o aluno se beneficiar do
potencial da auto-explicação através de um STI, o mesmo deve ser capaz de
realizar diálogos com o aluno no nível das explicações (POPESCU et al, 2003).
O modelo proposto foi elaborado tomando-se como base o referencial
teórico e também o estudo de alguns STIs existentes.
3.1. Trabalhos Relacionados
Vários STIs foram estudados de forma a auxiliar na elaboração do
projeto e definição do modelo desenvolvido. Dentre os quais é relevante citar:
• Geometry Explanation Tutor (ALEVEN et al, 2001), construído a
partir do PACT – Geometry Tutor (ALEVEN et al, 2001). Este STI
solicita que o aluno explique, com suas próprias palavras, as respostas
aos problemas de geometria apresentados.
• CIRCSIM-Tutor (ZHOU et al, 1999) apresenta ao aluno uma
descrição de uma mudança fisiológica e solicita predições sobre os
efeitos que esta mudança ocasiona sobre sete importantes aspectos
fisiológicos. A partir deste ponto, o STI conduz um diálogo com o aluno
30
visando corrigir os erros encontrados nas predições através de
entradas e saídas em texto livre.
• SE-Coach (CONATI et al, 1997) é um STI que permite orientar o
aluno na geração de auto-explicações corretas e efetivas e, como
conseqüência, melhorar o desempenho na resolução de problemas
dentro do domínio de Física, mais especificamente as Leis de Newton,
no nível universitário.
• CECELIA (REDMOND; PHILLIPS, 1997) é um STI aplicado ao
domínio de Química, mas especificamente para balanceamento de
equações. Projetado com os conceitos de Raciocínio Baseado em
Casos. O STI utiliza-se de técnicas de ensino que incluem a
apresentação passo-a-passo da solução do caso, predições e
explicações por parte do aluno das ações do especialista. O STI
explora uma estratégia de ensino a partir de exemplos, privilegiando a
resolução de uma grande quantidade de exemplos por parte do aluno
ao invés de inserir grandes quantidades de “inteligência” dentro do
tutor.
• AutoTutor (GRAESSER et al, 1999) é um STI que simula padrões
de discurso e estratégias educacionais de um típico tutor humano. Atua
no domínio de fundamentos de hardware, sistemas operacionais e
Internet em disciplinas de introdução à informática. O AutoTutor
apresenta questões e problemas a partir de um script, em seguida
procura compreender as contribuições colocadas pelo aluno e formula
diálogos que são sensíveis a estas contribuições.
31
• ELM-ART (BRUSILOVSKY et al, 1996) é um STI desenvolvido para
uso na internet, através de um navegador. Apresenta como objetivo
principal possibilitar o aprendizado da linguagem de programação Lisp.
Está baseado no ELM-PE (WEBER; MÖLLENBERG, 1994), que é um
ambiente de ensino inteligente que permite programação baseada em
exemplos, análises inteligentes das soluções dos problemas, além de
recursos avançados de teste e depuração.
• ACT Programming Tutor (CORBETT; BHATNAGAR, 1997) é um
STI construído com base em um modelo cognitivo de conhecimento de
programação. Consiste basicamente de um ambiente de resolução de
problemas no qual os alunos aprendem a escrever pequenos
programas em Lisp, Pascal ou Prolog.
Alguns dos tutores estudados, tais como o AutoTutor (GRAESSER et
al, 1999), CIRCSIM-Tutor (ZHOU et al, 1999) e SE-Coach (CONATI et al, 1997)
possuem capacidade de executar o processamento da língua natural através do
processamento estatístico da língua, correção ortográfica, identificação de
palavras-chave, análise sintática e análise semântica latente.
3.2. Modelo para o STI
O STI proposto, conforme mostrado na Figura 3, consiste basicamente
de dois subsistemas. O primeiro é o subsistema do professor que consiste
basicamente na interface entre o STI e o professor e é responsável pelo cadastro
dos exemplos e respectivas soluções, bem como permite a criação dos problemas
que serão apresentados ao aluno.
32
Figura 3: Proposta para o STI AutoExplC (adaptado de Freedman et al, 2000)
O subsistema do aluno permite a comunicação entre o STI e o aluno,
possibilitando ao mesmo visualizar as atividades cadastradas previamente pelo
professores e, em seguida, fornecer as explicações solicitadas.
O modelo proposto para o STI é composto primariamente por duas
bases de conhecimento:
a) Domínio - armazena as informações relacionadas ao assunto que
será ensinado, no caso a linguagem “C”;
b) Conhecimento do aluno - representa o nível de conhecimento atual
do aluno dentro do domínio.
Interface aluno-engenho
Engenho deinferência
Conheci- mento do
aluno
Domínio
Aluno
Professor
Interface do professor
33
Além das bases de conhecimento que compõem o STI, existem ainda:
a) Engenho de inferência que realiza inferências, baseadas na base de
conhecimento do aluno e do domínio.
b) Interface aluno-engenho que realiza a comunicação entre o aluno e
os demais módulos do STI e é capaz de prover um suporte eficaz para
as partes instrumentais da tarefa, por exemplo, minimizando a carga
cognitiva sobre a sintaxe e a depuração da programação, e que
segundo Trafton e Reiser (1993), auxilia no desenvolvimento dos
demais aspectos cognitivos necessários ao aprendizado de uma
linguagem de programação.
c) Interface do professor que realiza a comunicação entre o professor e
o STI e é responsável por permitir o cadastro de tópicos, explicações e
resoluções, além de permitir visualizar as explicações dos alunos.
3.3. Escolha da Forma de Representação do Conhecimento
A evolução dos STIs mostra a necessidade de se tratar não apenas do
conhecimento formal, mas também dos conhecimentos incertos e indeterminados
(PEROTTO; VICARI, 2001). Pesquisas recentes com algoritmos de Redes
Bayesianas têm permitido a modelagem de domínios complexos utilizando
representações probabilísticas (MURRAY; VANLEHN, 2000).
O formalismo das Redes Bayesianas permite ao usuário responder às
evidências em uma escala gradativa, com valores entre 0 e 1 (incerteza), além de
determinar regras ou padrões para tratar de uma evidência não informada, ou
seja quando há uma indeterminação.
34
Outra vantagem deste formalismo é permitir uma forma mais natural de
representação dos diferentes pesos relativos à influência de uma variável sobre
outra, além de tratar a incerteza e a indeterminação através de princípios
matemáticos fundamentados e modelar o conhecimento do especialista de um
modo claro e intuitivo.
Com base nas características citadas acima e devido ao bom
desempenho apresentado em outros tutores estudados como, por exemplo, o SE-
Coach (CONATI et al, 1997) e ACT Programming Tutor (CORBETT;
BHATNAGAR, 1997), as Redes Bayesianas foram escolhidas para representar o
conhecimento no STI proposto.
3.4. Definição das Rotinas para Entendimento Aproximado da Língua Natural
Os STIs têm auxiliado estudantes em diversos domínios, tais como
geometria, química e programação. Esses domínios são ideais, porque podem ser
facilmente representados e porque o tipo de interação entre o estudante e o STI
pode ser limitado à entrada de números, símbolos, ou simples palavras-chave.
Objetivando auxiliar estudantes de outras áreas e expandir os domínios para
aplicação dos STIs, surge a Análise Semântica Latente com sua abordagem
baseada em corpus, que permite a compreensão de uma entrada textual que não
é sensível a erros de ortografia ou gramática (WIEMER-HASTINGS et al, 1999).
No passado, os STIs mostraram grande eficiência em determinados
tipos de domínios. O LISP TUTOR auxiliou muitos estudantes as escrever
programas de uma maneira correta (CORBETT; ANDERSON, 1992). Os tutores
da álgebra e da geometria foram a base para o currículo de matemática no Ensino
Médio por dois anos (ANDERSON et al,1995). Estudantes de cursos de
35
graduação aprenderam física em um STI (VANLEHN et al, 1998). A eficiência
desses STIs é indiscutível, porém o tipo de interação que suportavam estava
limitado a pressionar teclas ou incorporar alguns números ou símbolos. Mesmo os
sistemas que aceitavam entradas do tipo texto livre dos estudantes estavam
limitados a entradas de uma única palavra (FREEDMAN et al, 1998). Esse tipo de
interação suportado pelos STIs conduz a uma limitação no escopo de utilização,
ou à profundidade atingida dentro do domínio. Sem os avanços significativos
obtidos na aplicação de técnicas da compreensão de língua natural, o uso de um
STI dentro de um domínio como história ou filosofia seria muito difícil (WIEMER-
HASTINGS et al, 1999).
Dentro deste contexto, surge uma nova geração de tutores, tal como, o
AutoTutor (GRAESSER et al, 1999), cujo projeto demonstra maneiras de suportar
uma interação de diálogo entre tutor e estudante em diversos tipos de domínios.
O elemento chave consiste na avaliação das respostas do estudante usando a
Análise Semântica Latente sobre uma sentença da língua natural.
Conforme ilustrado na Figura 4, o módulo de entendimento aproximado
da língua natural tenta efetuar as seguintes operações a partir da explicação
gerada pelo aluno:
• Análise Léxica - agrupa os caracteres em palavras (tokens) e, em
seguida, submete os tokens a um algoritmo de extração de radicais
(PORTER, 1980).
• Análise Sintática - recebe como entrada a seqüência de tokens
provenientes da análise léxica e gera uma árvore de derivação, se
estiver de acordo com a gramática.
36
• Análise Semântica Latente - a idéia chave de um analisador
semântico consiste no conceito de que o significado de uma sentença
pode ser obtido a partir do significado de cada uma de suas partes.
Figura 4: Proposta para as rotinas para entendimento aproximado da língua natural
- adaptado de Jurafsky e Martin (2000) e Wiemer-Hastings e outros (1999)
O módulo de entendimento aproximado da língua natural proposto
tenta minimizar o problema da precisão na determinação do conteúdo semântico
das explicações permitindo ao professor:
• Visualizar as explicações geradas pelos alunos e compará-las com
os resultados fornecidos pelo STI;
• Acrescentar lexemas não conhecidos ao léxico (RUSSEL; NORVIG,
1995).
3.5. Implementação
Na pesquisa realizada sobre ferramentas necessárias à implementação
do STI, foram priorizados os aspectos de desempenho, portabilidade e
distribuição gratuita. Desta forma, optou-se pela linguagem de programação Java
disponibilizada pela Sun, além do conector para banco de dados MySQL
Análise Léxica
Análise Sintática
Análise Semântica
Latente
37
Connector/J. Seguindo os mesmos critérios adotados acima, o sistema
gerenciador de banco de dados selecionado foi o MySQL.
Tal ferramental foi usado na implementação dos componentes do STI
apresentado a seguir.
3.5.1. Modelo do Domínio
Por definição, o modelo do domínio deve representar o conhecimento
de um especialista na área em que o sistema irá atuar. É composto por
conhecimentos declarativos e procedimentais. Para a representação dos
conhecimentos declarativos do modelo do domínio foram implementadas as
seguintes relações:
• Mapeador - contém os diversos comandos da linguagem “C”, com as
respectivas estruturas e lexemas da língua portuguesa associados que
são esperados durante a explicação do aluno.
• Tópico - contém os tópicos da linguagem de programação que são
cobertos pelo STI.
• Exemplo - contém o número e a descrição do problema proposto e o
código-fonte em linguagem “C” necessário para resolvê-lo.
• Explicação - contém as áreas do código-fonte (selecionadas pelo
professor) que o aluno será solicitado a explicar, além do tópico que
está relacionado à explicação.
• Peso-Explicação - cada explicação cadastrada possibilita a separação
dos diversos comandos da linguagem que compõem a explicação,
sendo que, para cada comando, é possível determinar um grau de
relevância dentro da explicação. Por padrão, a interface do professor
38
identifica todos os elementos da explicação como essenciais, porém, o
professor pode realizar a sua própria configuração.
3.5.2. Modelo do Estudante
O modelo do estudante possui a responsabilidade de representar o
grau de conhecimento do mesmo, seus acertos, erros e dificuldades. O modelo do
estudante é capaz de definir o nível de conhecimento do aluno a qualquer
momento dentro do sistema. Encontra-se implementado através das seguintes
relações:
• Aluno - armazena o código, nome e senha para acesso ao STI por parte
do estudante.
• Progresso - representa o nível de conhecimento do aluno, armazenando
suas explicações, acertos, tempos para resolução dos problemas
apresentados, além da avaliação gerada pelo STI após cada
explicação.
3.5.3. Interface Aluno-Engenho
A interface aluno-engenho possui como objetivos principais apresentar
os exemplos ao aluno. Em seguida, solicita ao aluno uma explicação. Após
receber a explicação gerada pelo aluno, a interface aluno-engenho envia a
mesma para o engenho de inferência.
3.5.4. Engenho de Inferência
O engenho de inferência é responsável por realizar o reconhecimento
aproximado da língua natural e classificar a explicação recebida. Ao receber a
39
explicação gerada pelo aluno, é realizada inicialmente a separação das palavras.
Em seguida, cada palavra é submetida à versão para língua portuguesa do
Algoritmo de Porter para extração de radicais - Porter Stemming Algorithm
(PORTER, 1980). Esta versão para língua portuguesa foi desenvolvida pelo
próprio Porter e encontra-se disponível no site do autor (PORTER, 1980).
A próxima etapa consiste em realizar Análise Semântica Latente
(WIEMER-HASTINGS et al, 1999), através da etiquetagem dos radicais. Para
isso, utiliza-se um corpus com 82.933 palavras etiquetadas da língua portuguesa
(AIRES, 2000). Em seguida, em relação ao trecho de código que deve ser
explicado, procura-se mapear os radicais para comandos da linguagem “C”, cujos
componentes constituem os nós de entrada de uma Rede Bayesiana.
Após realizar o mapeamento, a Rede Bayesiana é alimentada com
informações sobre os nós observados e não observados para, de acordo com os
pesos atribuídos pelo professor, realizar a classificação da explicação dentro de
três valores possíveis: correta, incompleta ou incorreta.
3.5.5. Interface do Professor
A interface do professor possibilita ao professor realizar o cadastro dos
alunos, visualizar as explicações geradas e também cadastrar os exemplos e as
respectivas soluções, bem como permite a criação das atividades que serão
apresentadas ao aluno e motivarão o mesmo a gerar explicações.
Dentro do cadastro das atividades, os componentes dos comandos da
linguagem “C” que compõem a atividade recebem sempre um peso padrão, ou
seja, todos os comandos receberão um mesmo peso. Porém, é possível ao
professor definir diferentes pesos para os diversos componentes. Por exemplo,
40
em um trecho de programa selecionado que contém um comando “while” e um
comando “if”, é possível atribuir um peso maior ao comando “while”. Quando o
aluno tiver explicado esta atividade, este fato fará o STI considerar de modo mais
relevante o trecho da explicação relacionado ao comando “while”, o que pode
resultar em uma avaliação correta mesmo na ausência de texto explicativo para o
comando “if”.
3.6. Funcionamento do STI Proposto
O STI proposto é composto pelo subsistema do professor e pelo
subsistema do aluno.
O subsistema do professor permite cadastrar os exemplos e identificar
o trecho do código-fonte que deverá ser explicado pelo aluno. Inicialmente, o
professor deve inserir o enunciado do problema proposto juntamente com o
programa que o resolve. No programa cadastrado, é possível identificar as linhas
que deverão ser explicadas e associá-las a um determinado tópico do STI.
No subsistema do professor também é possível visualizar as
explicações dadas pelos alunos, a classificação que o STI atribuiu às mesmas,
além de permitir ao professor acrescentar novos lexemas ao mapeador de
comandos da linguagem “C”.
A execução do subsistema de aluno inicia-se apresentando um
exemplo de programa em Linguagem “C”. A próxima etapa consiste em instruir o
aluno a explicar o propósito de trechos de comandos utilizados na resolução do
problema proposto.
O aluno, por exemplo, poderá explicar o funcionamento de qualquer
função ou variável seguindo qualquer ordem dentro do trecho apresentado, não
41
necessariamente da esquerda para a direita. O aluno deverá trabalhar no trecho
apresentado até que o mesmo esteja adequadamente explicado.
Portanto, o subsistema do aluno executa as seguintes tarefas:
apresentar o tópico que será ensinado, exibir o código fonte de um exemplo,
solicitar ao aluno que explique um determinado trecho do exemplo, permitindo ao
aluno criar auto-explicações. Em seguida, ocorre a avaliação da explicação,
sendo determinada a mensagem que deverá ser apresentada ao aluno.
Figura 5: Diagrama entidade-relacionamento dos modelos do STI
Com o intuito de ilustrar o funcionamento dos Subsistemas do Aluno e
do Professor que são abordados a seguir, a Figura 5 mostra o diagrama entidade-
relacionamento das relações existentes nos modelos do STI. No Apêndice A é
detalhado a estrutura das relações com explicações sobre os conteúdos dos
campos.
3.6.1. Subsistema do Professor
A janela inicial do subsistema do professor apresenta os exemplos
cadastrados e também um menu com os recursos disponíveis (Figura 6).
Resolver
Exemplo
Aluno
Possuir Progresso
Explicação Possuir
Gerar
Peso-Explicação
Mapeador Acessar
Corpus
Etiqueta
Possuir
42
Ao acessar esta janela, o professor pode escolher um exemplo já
cadastrado ou pressionar o botão Incluir exemplo, para que a janela de Cadastro
do Exemplo seja exibida (Figura 7). Na janela cadastro do exemplo, o professor
formula um problema e, em seguida, cadastra o código-fonte em “C” necessário
para a resolução do problema.
Figura 6: Janela inicial do subsistema do professor.
Figura 7: Cadastro do Exemplo
Na próxima etapa, o professor cadastra as atividades, para as quais
serão solicitadas as explicações, que deverão ser geradas para o respectivo
exemplo. Para isso, basta apenas selecionar o trecho do código fonte que deverá
ser explicado e, em seguida, pressionar o botão Incluir. A janela de cadastro da
43
atividade é exibida (Figura 8) e o professor deve cadastrar um texto de ajuda para
a explicação e associar a atividade a um determinado tópico da Linguagem “C”.
Figura 8: Cadastro da Atividade
Após o cadastro da atividade, ainda é possível ajustar a importância
relativa de cada parte do trecho de código-fonte selecionado, atribuindo pesos
diferenciados através dos botões Essencial, Necessária e Desejada existentes na
Janela de Cadastro do Exemplo. O padrão consiste em aplicar o peso “Essencial”
(texto formatado em vermelho) para todos os componentes do trecho do código-
fonte. Neste exemplo, pode-se observar que o trecho do programa “maior = v[i];”
está indicado como “Necessário”, ou seja, o professor definiu um peso menor
para esta linha, em relação ao restante do trecho do código-fonte. Para realizar
esta definição, o professor selecionou o trecho do programa “maior = v[i];” e, em
seguida, pressionou o botão “Necessário”. O STI não permite, para fins de
atribuição de pesos, que o professor utilize trechos que não se encontram dentro
do código-fonte selecionado.
A seguir, detalha-se como essa etapa é conduzida internamente pelo
subsistema, bem como as bases de dados envolvidas. Na primeira etapa, que
consiste no cadastro do exemplo, é utilizada apenas a relação Exemplo.
Após o cadastro do exemplo, o professor seleciona os trechos do
código-fonte que deverão ser explicados. Em seguida, realiza-se a verificação e a
separação dos componentes do código-fonte que foi selecionado e a janela de
cadastro das atividades é exibida (Figura 8).
44
Para realizar a separação dos componentes do código-fonte
selecionado são utilizadas, como referência, as informações contidas na relação
Mapeador. Esta relação apresenta como finalidade armazenar a sintaxe das
instruções da Linguagem “C” suportadas pelo tutor.
Com o objetivo de ilustrar a utilização da relação Mapeador, a seguir, é
analisado como o comando “if-else” da linguagem “C” é armazenado nesta
relação (Tabela 1).
Tipo Comando Sintaxe Terminador Número-Componente Deslocamento Lexema
id# If id# (expr#) ) 2 0
<e>caso; verificar; testar; se; quando;</e>
id# else id# N 1 0
<e>senão; caso; contrário; outra; forma; outra; maneira;</e>
Tabela 1: Armazenamento da estrutura “if-else” na relação Mapeador
O comando “if-else” é armazenado em duas linhas da respectiva
relação, sendo que a primeira coluna armazena o tipo do componente e pode ser
id# para representar palavras reservadas linguagem, opla# para operadores
lógico ou aritmético, opat# para operadores de atribuição, expr# para expressões,
atrib# expressões de atribuição e var# para identificar variáveis da linguagem.
A coluna comando contém o radical que corresponde ao comando,
enquanto a coluna sintaxe o formato esperado. Na coluna terminador, é
encontrado o caracter que finaliza a linha de comando, neste caso o valor N,
presente para a linha que representa o “else”, indica que não há caracter
terminador. A coluna número de componentes indica a quantidade de
componentes que formam o comando. Por exemplo, a linha do comando “if”
45
indica a existência de dois componentes, que são a palavra reservada “if”,
seguida de uma expressão delimitada por parêntesis.
A coluna deslocamento informa, incluindo o comando, onde começam
os componentes do comando. Por exemplo, considerando a linha do comando “if”
este campo assume o valor zero, pois, não existem componentes do comando à
esquerda da palavra reservada “if”. Por outro lado, considerando uma instrução
“j++”, este campo assumiria o valor “–1”, pois antes do operador “++” existe um
componente do operador, neste caso, a variável “j”.
Finalizando, a coluna lexema indica quais palavras, da Língua
Portuguesa, são esperadas durante o processo de entendimento aproximado da
língua natural. Quanto utilizada, a etiqueta <e> indica que são lexemas
essenciais, ou seja, pelo menos um deles é esperado para poder mapear o
lexema. Por outro lado, a etiqueta <o> indica um lexema opcional que pode ou
não estar presente na explicação e que não influenciará no processo de
mapeamento. Considerando o exemplo apresentado na Tabela 1, para identificar
a palavra reservada “if”, deverá ser obrigatoriamente encontrado dentro da
explicação do aluno um dos seguintes lexemas: “caso”, “verificar”, “testar”, “se” ou
“quando”.
Voltando à Figura 7, uma vez separados todos os componentes, são
armazenadas as suas posições de início e término dentro do código-fonte para
fins de formatação do texto a ser exibido pela interface aluno-engenho. As
posições de início e término são determinadas, em termos de caracter, a partir do
início do programa cadastrado. Neste momento, também é atribuído, por padrão,
o peso “Essencial” a todos os componentes, de modo que todos, em um primeiro
momento, apresentam o peso “Essencial”.
46
Ao preencher os campos do cadastro de atividades e escolher a opção
gravar, as informações relativas à atividade serão armazenadas nas relações
Explicação e Peso-Explicação.
A Tabela 2 mostra como é realizada a separação e a inclusão dos
pesos da explicação apresentada no exemplo anterior (Figura 6). É importante
observar também a alteração da importância do componente “maior = v[i]” de
“Essencial” (Importância = 4) para “Necessária” (Importância = 2) e o respectivo
ajuste dos pesos. Sendo que os pesos são atribuídos através da média
ponderada dos pesos em relação ao contexto geral da atividade que está sendo
cadastrada. Por exemplo, considerando a Tabela 2, tem-se que a soma das
importâncias dos componentes é 10 (4 + 4 + 2), desta forma, considerando a
primeira linha da Tabela 6, que representa o componente “if”, determina-se que o
peso é 0,4 (4 / 10).
Número-Exemplo
Número- Explicação
Seleção- Início
Seleção- Término Componente Importância Peso
6 1 94 95 if 4 0,4 6 1 98 109 v[i] > maior 4 0,4 6 1 121 132 maior = v[i] 2 0,2
Tabela 2: Inclusão na relação Peso-Explicação
As atividades definidas pelo professor neste subsistema irão compor a
seqüência de exercícios que o aluno irá tentar resolver. Esta seqüência será
mostrada ao aluno seguindo uma ordenação através do número do tópico
associado à atividade depois, dentro do tópico, a ordem de cadastro do exemplo e
finalizando, dentro do exemplo, a ordem de cadastro da explicação.
No subsistema do professor, além das etapas descritas anteriormente,
também é possível realizar o cadastro dos tópicos da linguagem que serão
abordados e os alunos que utilizarão o tutor. Outra opção disponível consiste na
47
visualização das explicações geradas pelos alunos e a respectiva avaliação
gerada pelo STI.
3.6.2. Subsistema do Aluno
O subsistema do aluno, que é composto pela interface aluno-engenho
e pelo engenho de inferência, inicia-se realizando a identificação do aluno que irá
utilizar o STI. Após a sua identificação (Figura 9), procura-se na relação progresso
o seu estágio atual de evolução dentro do STI. Para isso determina-se, a partir da
seqüência definida pelo professor, quais as atividades que já foram executadas
com sucesso e quais estão pendentes. A barra de progresso, mostrada na
porção inferior do subsistema do aluno (Figura 10), mostra o estágio atual do
aluno em comparação com as atividades propostas. Uma vez definido o estágio
atual do aluno, carrega-se o exemplo adequando, salientando os trechos do
código-fonte que deverão ser explicados.
Figura 9: Conexão com a aplicação do aluno
Considerando o exemplo cadastrado anteriormente, o STI apresenta ao
aluno a janela mostrada na Figura 10 e aguarda uma explicação relacionada à
utilização do comando “if”:
48
Figura 10: Janela principal da aplicação do aluno
O aluno formula a explicação e pressiona o botão Avaliar. O STI recebe
a explicação e, através do componente de entendimento aproximado da língua
natural existente no engenho de inferência, tenta mapear a explicação gerada
pelo aluno em comandos da Linguagem “C”.
Ilustrando o funcionamento do subsistema do aluno, é considerada a
seguinte explicação do aluno para a atividade proposta na Figura 10: “verificar se
v índice i é maior que a variável maior então atribuir v índice i à variável maior”.
Lexema Radical Lexema Radical Lexema Radical verificar {verific} que {que} índice {índic} se {se} a {a} i {i} v {v} variável {variável} a {à} índice {índic} maior {maior} variável {variável} i {i} então {entã} maior {maior} e {é} atribuir {atribu} maior {maior} v {v}
Tabela 3: Extração dos radicais
49
O componente de entendimento aproximado da língua natural
inicialmente recebe a explicação e a separa em palavras. O próximo passo
consiste em efetuar a associação dos radicais a partir das palavras conforme
mostrado na Tabela 3.
Após a extração dos radicais, os mesmos são submetidos a um
processo de pré-etiquetagem, que consiste basicamente em identificar, entre os
radicais dos lexemas, os nomes das variáveis utilizadas no bloco de código-fonte
que foi explicado. É importante observar no quadro abaixo que as variáveis do
programa recebem uma etiqueta (VAR) e recebem na propriedade “observado” do
nó o valor verdadeiro (v), ou seja, foram identificados dentro da explicação. Por
exemplo, considerando a variável “i” (Tabela 4), a mesma irá receber uma
etiqueta com a identificação de “VAR” e é identificada como “observada”
(mapeada) dentro da explicação dada pelo aluno.
Lexema Etiqueta Lexema Etiqueta verificar {verific} maior {maior: VAR, v} se {se} então {entã} v {v: VAR, v} atribuir {atribu} índice {índic} v {v: VAR, v} i {i: VAR, v} índice {índic} é {é} i {i: VAR, v} maior {maior: VAR, v} a {à} que {que} variável {variável} a {a} maior {maior: VAR, v} variável {variável}
Tabela 4: Pré-etiquetagem dos radicais
Concluída a pré-etiquetagem, os lexemas que não foram mapeados
como nome de variável são, então, enviados para o processo de etiquetagem
propriamente dito, o qual está baseado em um Corpus com lexemas da língua
portuguesa (AIRES, 2000).
O componente de entendimento aproximado da língua natural procura
por lexemas com radicais similares para realizar a etiquetagem dos lexemas
remanescentes. Por exemplo, considerando o lexema “verificar”, que possui o
50
radical “verific”, a consulta ao Corpus irá retornar as seguintes possibilidades de
etiquetas para o lexema:
Lexema Etiqueta Ocorrênciasverificar VTD 5 verifica VTD 1 verificados VTD 1
Tabela 5: Resultado da pesquisa na relação Corpus
Neste caso, quando identificada alguma ambigüidade será escolhida a
etiqueta do lexema que apresentar maior número de ocorrências dentro do
corpus.
Após a etiquetagem de todos os lexemas existentes na explicação, o
componente de entendimento aproximado da língua natural retira os lexemas
irrelevantes para a determinação do conteúdo da explicação, como por exemplo,
artigos e adjuntos adverbiais. As regras utilizadas para desconsiderar os lexemas
irrelevantes estão definidas dentro da relação Etiqueta. Por exemplo,
considerando o lexema verificar, é possível observar que o mesmo recebeu a
etiqueta “VTD” (Tabela 5). Realizando a procura desse lexema na relação
Etiqueta no banco de dados, obtém-se um resultado indicando que se trata de um
verbo transitivo direto, o que significa que o mesmo não pode ser ignorado na
etapa seguinte (mapeamento).
Lexema Etiqueta Lexema Etiqueta
verificar {verific: VTD, v} maior {maior: VAR, v} se {se: PPOA, f} então {entã: ADV, d} v {v: VAR, v} atribuir {atribu: VBI+PPOA, v} índice {índic: N, f} v {v: VAR, v} I {i: VAR, v} índice {índic: N, f} é {é: VLIG, f} I {i: VAR, v} maior {maior: VAR, v} à {à: PREP+ART, f} que {que: PR, f} variável {variável: ?, f} a {a: PREP, d} maior {maior: VAR, v} variável {variável: ?, f}
Tabela 6: Mapeamento dos lexemas da explicação
51
A última etapa de funcionamento do componente de entendimento
tenta mapear os lexemas em comandos da Linguagem “C”. Este processo
consiste, com base na relação Mapeador, em encontrar as instruções associadas
aos lexemas utilizados na explicação. O resultado obtido ao final desta etapa é
apresentado na Tabela 6.
Onde, um valor verdadeiro (v) na etiqueta indica que o lexema foi
mapeado para um comando da linguagem “C”. Falso (f) demonstra que não foi
possível mapear o lexema. E desprezado (d) significa que o lexema não foi
considerado relevante para identificação do significado da explicação. Por
exemplo, a partir do lexema verificar é possível determinar, a partir da Tabela 1,
que o mesmo permite mapear um comando “if”, pois o mesmo possui os
seguintes lexemas determinados como essenciais: “caso”, “verificar”, “testar”, “se”
e “quando”. Neste momento, o nó relativo ao comando “if” (Figura 11) é
determinado como “observado”.
Desta forma, o subsistema do aluno determina a proximidade entre o
trecho de código-fonte esperado e o mapeado, alimentando os nós da Rede
Bayesiana (Figura 11) com os componentes esperados pela explicação, os
respectivos pesos e se o nó conseguiu ser mapeado pelo componente de
entendimento aproximado da língua natural. O resultado, produzido pela Rede
Bayesiana indica o grau de proximidade da explicação gerada pelo aluno em
relação ao esperado pelo professor.
52
Figura 11: Nós da Rede Bayesiana
A partir do resultado gerado pela Rede Bayesiana, o STI classifica a
explicação do aluno em correta, incompleta ou incorreta, determinando se o aluno
irá prosseguir para uma nova atividade ou se deverá repetir ou completar a
explicação gerada originalmente. A classificação da explicação do aluno é
determinada pelas seguintes faixas:
• Correta - soma dos pesos dos componentes da explicação
determinadas pelo professor em relação ao “ideal”, sendo determinada
da seguinte forma:
Ideal = número de componentes * importância “essencial”
No exemplo: Ideal = 3 * 4 = 12
Tolerância máxima = soma das importâncias definidas pelo
professor. No exemplo: Tolerância máxima = 4 + 4 + 2 = 10
Correta = Tolerância máxima / Ideal
Considerando o exemplo: Correta = 10 / 12 * 100 = 83,33%
• Incorreta - apresenta valores entre zero e o mínimo aceitável, sendo
determinado da seguinte maneira:
Tolerância mínima = soma das importâncias atribuídas pelo
professor diferentes de “essencial”. No exemplo:
Tolerância mínima = 2
if
v[i] > maior
maior = v[i]
avaliação
Peso: 0,4Observado: sim
Peso: 0,4Observado: sim
Peso: 0,2Observado: sim
53
Incorreta = Tolerância mínima / Ideal. Considerando o exemplo:
Incorreta = 2 / 12 * 100 = 16,66%
• Incompleta - deve estar entre a porcentagem identificada no item
Correta e também ser maior que o mínimo aceitável. Sendo, para este
exemplo, definida uma faixa entre 16,66 % e 83,33%.
Em resumo, considerando os pesos cadastrados para a atividade
mostrada na Tabela 2, é possível definir as seguintes faixas de valores para a
classificação da explicação:
Classificação Faixa Correta >= 83,33% Incompleta > 16,66 % e < 83,33% Incorreta <= 16,66%
Tabela 7: Exemplo das faixas para classificação de uma explicação
Uma vez realizada a classificação da explicação gerada pelo aluno,
toda a informação pertinente é inserida na relação progresso (Tabela 8). Um
procedimento de consulta às informações contidas nesta relação permite
determinar instantaneamente o desempenho do aluno perante as atividades
propostas, além de permitir ao professor analisar as avaliações geradas pelo STI.
A partir de uma análise mais aprofundada da Tabela 8 é importante,
neste momento, detalhar o conteúdo armazenado no campo Avaliação que
consiste, na verdade, na síntese de todos os passos realizados pelo STI para
gerar a classificação da explicação recebida, conceitos estes que serão de grande
importância para o entendimento dos capítulos subseqüentes. Dentro deste
campo, inicialmente, deve ser observado o resultado da etapa de entendimento
aproximado da língua natural. Esta etapa consiste em identificar cada lexema
constituinte da explicação, seguido do seu radical, etiqueta e se o mesmo foi
mapeado, ou não, ou ainda, se foi desconsiderado. Por exemplo, considerando o
lexema “verificar”, tem-se “{verific: VTD, v}”. O próximo parâmetro, armazenado
54
neste campo, consiste no índice de lexemas reconhecidos que corresponde à
porcentagem dos lexemas que compõem a explicação e que foram mapeados. No
exemplo mostrado na Tabela 8, tem-se que dos 19 lexemas que compõem a
explicação 9 foram mapeados e 2 foram desprezados, desta forma, o índice é
calculado como (9 + 2) / 19, ou seja, 0,5789.
Campo Valor Código-Aluno 011 Número-Tópico 15 Número-Exemplo 6 Número-Explicação
1
Tentativa 2 Bloco-Código if (v[i] > maior)
maior = v[i]; Explicação verificar se v índice i é maior que a variável maior então atribuir v índice i à
variável maior Avaliação (do STI) Entendimento aproximado da língua natural: verificar {verific: VTD, v} se {se:
PPOA, f} v {v: VAR, v} índice {índic: N, f} i {i: VAR, v} é {é: VLIG, f} maior {maior: VAR, v} que {que: PR, f} a {a: PREP, d} variável {variável: ?, f} maior {maior: VAR, v} então {entã: ADV, d} atribuir {atribu: VBI+PPOA, v} v {v: VAR, v} índice {índic: N, f} i {i: VAR, v} à {à: PREP+ART, f} variável {variável: ?, f} maior {maior: VAR, v} Índice de lexemas reconhecidos: 0.5789473684210527 Mapeamento:(if v), (v v), (i v), (> v), (maior v), (maior v), (= v), (v v), (i v), Classificador:if 0.4 true v[i] > maior 0.4 true maior = v[i] 0.2 true Avaliação: 1.0 Faixas: 0.1666 - 0.8333 Classificação: C – Correta AutoExplC: Ótimo é isso mesmo.
Situação (Classificação)
C
Data-Início 1/9/2005 20:10:34 Data-Término 1/9/2005 20:10:34
Tabela 8: Exemplo de um registro da relação Progresso
O parâmetro mapeamento mostra os componentes que integram o
trecho do código fonte da explicação e se foram, ou não mapeados. Por exemplo,
“(if v)” indica que a palavra reservada “if” foi mapeada. O parâmetro classificador é
responsável por representar os nós da Rede Bayesiana, com seus respectivos
nome, peso e observação. Por exemplo, “if 0.4 true” indica o nó relacionado à
palavra reservada “if” (Figura 11), com o peso de 0,4 e, também, que o mesmo foi
observado a partir do mapeamento da explicação (true).
55
O parâmetro avaliação contém o resultado gerado pela Rede
Bayesiana, este parâmetro posteriormente é comparado com o parâmetro faixas
que contém os valores base para classificação da explicação como correta,
incompleta ou errada. Por exemplo, o parâmetro faixas com os valores 0,1666 –
0,8333, indica que a saída produzida pela Rede Bayesiana será considerada
errada se apresentar um valor menor ou igual a 0,1666, será considerada
incompleta se apresentar valor maior que 0,1666 e menor que 0,8333 e, por fim,
será considerada correta se apresentar um valor maior ou igual a 0,8333 (Tabela
7). O resultado obtido é encontrado no parâmetro classificação.
Tomando como base a classificação da explicação, o STI apresenta ao
aluno um retorno quanto ao seu progresso (parâmetro AutoExplC), indicando o
que o aluno deverá fazer em seguida, que pode ser a mesma atividade, no caso
de explicações erradas ou incompletas, ou uma outra atividade, para o caso de
explicações consideradas corretas pelo STI.
4. RESULTADOS
57
O STI proposto foi avaliado a partir da especificação de 25 atividades
(Apêndice B) e da submissão do mesmo a um conjunto de 125 explicações
(Apêndice C). Essas explicações encontram-se divididas em três níveis, sendo
que a intenção primária desta avaliação consiste em tentar verificar quatro pontos
determinantes para o funcionamento do STI:
• Velocidade do módulo de entendimento aproximado da língua
natural. Pois, considerando o fator interação aluno-tutor, um dos fatores
primordiais no STI consiste no rápido retorno ao aluno da avaliação
sobre a explicação recebida;
• Detecção de explicações erradas, sem relação com o domínio (Nível
1): O tutor deve diagnosticar como errada uma explicação que não
apresente relação alguma com o domínio. Desta forma, definiu-se que
este nível é composto por 25 explicações que contém lexemas que
foram sorteados ao acaso (aleatoriamente) dentro do Corpus. As
explicações, na quase totalidade, não apresentam sentido algum.
• Detecção das explicações erradas, relacionadas com o domínio
(Nível 2): O tutor não deve aceitar uma série de lexemas relevantes ao
domínio, porém sintaticamente sem sentido algum, ou seja explicações
construídas ao acaso utilizando apenas lexemas referentes ao domínio.
Este nível também é composto por 25 explicações. Foi realizado o
mesmo procedimento com relação ao Nível 1, porém, há uma diferença
fundamental: apenas lexemas que são suportados pelo mapeador de
comandos “C” do STI foram utilizados no processo de geração.
• Detecção de explicações geradas por um ser humano (Nível 3): O
tutor deveria se comportar, adequadamente, a partir de situações
58
“reais”, considerando explicações que apresentam um conteúdo
relevante ao contexto em estudo e frases sintaticamente corretas e que
englobam erros, acertos e incompletudes. São 75 explicações
sintaticamente corretas, construídas por um ser humano, especialista
no domínio de atuação do STI. Todas as frases apresentam algum
sentido dentro do contexto de aplicação do tutor e, dentre as mesmas,
encontram-se explicações corretas, incompletas e erradas igualmente
distribuídas.
As atividades propostas apresentam vários graus de complexidade,
abrangendo desde a solicitação de explicação para um simples comando,
passando pela explicação de uma linha e, finalizando com a explicação de
trechos do programa, ou seja, várias linhas do código fonte. A intenção, neste
caso, consiste em tentar determinar a precisão do STI a partir de vários graus de
complexidade das atividades propostas e, por conseqüência, a complexidade da
explicação.
Após a submissão ao STI do conjunto de explicações de acordo com
as atividades propostas (Apêndice B) comparou-se, inicialmente, o tempo de
execução do módulo de entendimento aproximado da língua natural para cada
uma das frases. Posteriormente, como o objetivo de avaliar a precisão do STI na
avaliação das explicações, determinou-se para cada tipo de classificação gerada
a média, mediana, desvio padrão e intervalo de confiança em relação ao
esperado, determinado, neste caso, por um especialista humano.
59
4.1. Avaliação Preliminar
Conforme mostrada na Tabela 18, uma primeira avaliação demonstrou
um funcionamento satisfatório do STI quanto à velocidade de execução do
módulo de entendimento aproximado da língua natural com um tempo médio para
avaliação da explicação do aluno de 100ms e máximo de 700ms. Estes valores
foram obtidos através da média e do valor máximo da diferença de tempo entre os
valores dos campos Data-Término e Data-Início existentes na relação Progresso
(Tabela 17). Nesta avaliação, a exibição das atividades, por parte de interface do
aluno, foi desativada de modo que os tempos armazenados nos campos Data-
Término e Data-Início correspondem, respectivamente, ao início e término da
execução do componente de entendimento aproximado da língua natural e do
engenho de inferência para cada uma das explicações submetidas.
Apesar dos resultados gerais mostrarem um funcionamento adequado
do STI na questão da avaliação das explicações recebidas, foi observado uma
falha no entendimento de algumas explicações como mostrado na Tabela 9. Nos
níveis 1, 2 e 3, respectivamente, foram classificadas 1, 17 e 15 questões como
corretas quando, na verdade, esperava-se nenhuma correta. Além de 7, 91 e 14
explicações classificadas como incompletas nos níveis 1, 2 e 3, respectivamente.
Esperado Respostas Obtidas Nível Errada Correta Incompleta Errada
1 Total 625 1 7 617 Média 100,00% 0,16% 1,12% 98,72% 2 Total 625 17 91 517 Média 100,00% 2,72% 14,56% 82,72% 3 Total 625 15 14 596 Média 100,00% 2,40% 2,24% 95,36% Total Geral 1.875 33 112 1.730
Média 92,27% Mediana 95,36% Desvio Padrão 8,44% Invervalo de Confiança 0,0003276
Tabela 9: Avaliação Preliminar – Respostas Erradas
60
Após uma análise detalhada das explicações inadequadamente
classificadas, foi constatado que o problema era devido a uma falha no
entendimento de explicações muito simples, ou seja, aquelas geradas
exclusivamente para explicar um único comando da linguagem. Esse erro ocorria
quando a explicação de um único comando era avaliada, gerava-se um peso
elevado para a Rede Bayesiana que, conseqüentemente, ocasionava a
irrelevância de qualquer outro componente existente na explicação. Por exemplo,
considerando a Tabela 10, a presença do lexema “digitar” na explicação, lexema
este relacionado ao comando “getchar()” no mapeador, faz com que a explicação
seja classificada como correta.
Bloco-Código Explicação Avaliação (do STI)
getchar() dividir precisão dados enquanto subtrair ponteiro dividir multiplicar digitar executar curto sem atribuir
Entendimento aproximado da língua natural: dividir {divid: N, f} precisão {precisã: N, f} dados {dad: N, f} enquanto {enquant: CONJSUB, d} subtrair {subtra: ?, f} ponteiro {ponteir: ?, f} dividir {divid: N, f} multiplicar {multiplic: VTD, f} digitar {digit: N, v} executar {execut: VINT, f} curto {curt: ADJ, f} sem {sem: PREP, d} atribuir {atribu: VBI+PPOA, f} Mapeamento: (getchar v), Classificador: getchar 1.0 true Avaliação: 1.0 Faixas: 0.0 - 1.0 Classificação: C - Correta AutoExplC: Está correto!
Tabela 10: Problema da classificação de explicações sobre um único comando
Com o objetivo de minimizar este problema, foi acrescentado à Rede
Bayesiana mais um nó que é responsável por apresentar um peso relativo para os
lexemas existentes na explicação mas que não foram mapeados pelo módulo e,
desta forma, determinar um peso para o contexto da explicação recebida em
relação à atividade proposta. Após sucessivos testes com o arquivo de avaliação,
61
determinou-se que o melhor desempenho do STI ocorre quando esse nó é
ajustado para “observado” quando a explicação possui menos que 55% dos
lexemas mapeados.
4.2. Avaliação Final
Uma vez constatado um funcionamento mais satisfatório do módulo de
entendimento aproximado da língua natural com a implementação da resolução
para o problema acima descrito, o STI foi submetido a uma nova avaliação,
respeitando-se o mesmo conjunto de atividades e explicações submetidas na
avaliação preliminar.
Analisando o desempenho do STI com relação ao tempo de execução,
não foram observadas mudanças, permanecendo os mesmos valores médio e
máximo.
A Tabela 11 mostra uma síntese do desempenho obtido pelo STI
referente às respostas erradas encontradas nos três níveis da avaliação, cuja
análise encontra-se no próximo capítulo.
Esperado Respostas Obtidas Nível Errada Correta Incompleta Errada
1 Total 625 - 4 621 Média 100,00% 0,00% 0,64% 99,36% 2 Total 625 - 68 557 Média 100,00% 0,00% 10,88% 89,12% 3 Total 625 3 23 599 Média 100,00% 0,48% 3,68% 95,84% Total Geral 1.875 3 95 1.777
Média 94,77% Mediana 95,84% Desvio Padrão 5,20% Invervalo de Confiança 0,0001364
Tabela 11: Avaliação Final – Respostas Erradas
É importante observar, na coluna das respostas corretas obtidas, o
efeito da modificação realizada no módulo. Houve uma redução significativa do
62
número de ocorrências de classificações indevidas, ou seja, a Tabela 9 (Avaliação
Preliminar) apresenta 33 casos contra apenas 3 na Avaliação Final (Tabela 11).
Observando as colunas com as explicações indevidamente classificadas como
incompletas ocorreu também uma redução, em escala menor, de 112 (Tabela 9)
para 95 casos (Tabela 11).
5. DISCUSSÃO
64
O STI proposto apresentou um desempenho satisfatório. Os
resultados, quanto analisados de uma maneira global, mostram um
funcionamento adequado do módulo de entendimento aproximado da língua
natural. Por outro lado, questões relacionadas à identificação do contexto da
explicação, dentro da atividade proposta para o STI, podem ser melhorados em
trabalhos futuros.
A qualidade das atividades cadastradas pelo professor também
apresenta um fator determinante para um bom desempenho do STI, assim como
ocorre em qualquer outra atividade que envolve a interação entre professor-aluno,
por exemplo, elaboração de listas de exercícios e formulação de questões para
uma avaliação. Por exemplo, as atividades devem ser elaboradas com o intuito de
verificar o entendimento que aluno possui sobre determinado tópico, permitindo
também, que ao gerar as explicações solicitadas pelo STI, o aluno amplie e
complemente esse entendimento. Para atingir a esse objetivo, o professor deve
evitar a formulação de atividades sobre apenas um determinado comando,
variável ou função da linguagem “C”, dando preferência a construção de
atividades que envolvam uma ou mais linhas do código-fonte.
Número Bloco de Código Componente Importância Peso while Essencial 0,444444ch != ‘A’ Essencial 0,444444
10
while (ch != ‘A’) ch = getchar(); ch = getchar Desejada 0,111111
Tabela 12: Exemplo da influência dos pesos dos nós
Outra característica relevante consiste na correta aplicação dos pesos,
que devem sem compatíveis ao nível de entendimento que o professor deseja
que o aluno atinja. Pois, esses pesos são determinantes no momento de realizar
a classificação da explicação gerada pelo aluno. Para ilustrar essa consideração,
analisando a atividade 10 (Tabela 12), é possível observar que foi atribuído um
65
peso maior aos componentes da explicação relacionados à linha do comando
“while” enquanto a linha que apresenta a função “getchar()” apresenta um peso
mínimo. Essa característica da atribuição de pesos determina que o STI
considerará muito mais as explicações que se referem apenas ao comando
“while”, mesmo na presença das que se referenciem ao funcionamento do
“getchar()” e à atribuição recebida pela variável “ch”. Desta forma, a explicação
“enquanto ch diferente de A” seria classificada como correta pelo STI enquanto
um especialista humano diria que a mesma está incompleta.
5.1. Análise da Avaliação Preliminar
A avaliação preliminar foi importante no sentido de tentar determinar o
funcionamento como um todo do STI. Porém, com preocupações adicionais
relacionadas à velocidade de execução do engenho de inferência e do
componente de entendimento aproximado da língua natural, além da precisão da
avaliação das explicações por parte do tutor.
Os resultados obtidos foram satisfatórios, mostrando apenas uma
necessidade de ajuste da Rede Bayesiana para explicações sobre um único
comando da linguagem “C”. Este problema está em grande parte relacionado à
complexidade da explicação necessária, para pequenos códigos a serem
explicados. Por exemplo, o STI nas atividades 11, 14, 15 e 25, apresentadas na
Tabela 13, apresentou dificuldade em determinar o contexto da explicação gerada
e acabou aceitando como corretas várias explicações erradas. Por outro lado, foi
observado que a eficiência do STI aumentou, conforme aumentou o grau de
complexidade da explicação esperada, por exemplo, nas atividades 4, 6, 17, e 23
mostradas na Tabela 13.
66
Número Bloco de Código Componente Importância Peso while Essencial 0,285714i < y Essencial 0,285714i ++ Essencial 0,285714
4
while(i<y) { i++; r*=x; } r *= x Necessária 0,142857
if Essencial 0,4v[i] > maior Essencial 0,4
6
if (v[i] > maior) maior = v[i]; maior = v[i] Necessária 0,2
11 getchar() getchar Essencial 114 break break Essencial 115 default default Essencial 1
for Essencial 0,190476int i = 0 Desejada 0,047619i < 3 Essencial 0,190476i ++ Essencial 0,190476auxiliar[j] = vetor[i] Essencial 0,190476
17
for (int i = 0; i < 3; i++) { auxiliar[j] = vetor[i]; j--; } j -- Essencial 0,190476
if Essencial 0,333333v[j] < v[menor] Essencial 0,333333
23
if (v[j] < v[menor]) menor = j; menor = j Essencial 0,333333
25 void void Essencial 1Tabela 13: Algumas atividades propostas
Não se pode esquecer do nó que foi adicionado à Rede Bayesiana. O
peso atribuído a este nó tenta determinar o grau de similaridade do contexto da
explicação dentro da atividade proposta. Este grau de similaridade é determinado
identificando-se o percentual de lexemas existentes na explicação que foram
mapeados. Considerando o exemplo mostrado na Tabela 10, apenas 3 lexemas
(“enquanto”, “digitar” e “sem”) de um total de 13 lexemas (Tabela 14) foram
mapeados. Desta forma, determina-se o índice de lexemas reconhecidos em
torno de 23%.
Lexema Etiqueta Lexema Etiqueta
dividir {divid: N, f} multiplicar {multiplic: VTD, f} precisão {precisã: N, f} digitar {digit: N, v} dados {dad: N, f} executar {execut: VINT, f} enquanto {enquant: CONJSUB, d} curto {curt: ADJ, f} subtrair {subtra: ?, f} sem {sem: PREP, d} ponteiro {ponteir: ?, f} atribuir {atribu: VBI+PPOA, f} dividir {divid: N, f}
Tabela 14: Etiquetagem dos lexemas que compõem a explicação
67
Como este índice está abaixo de 55%, o respectivo nó é ajustado como
observado e a classificação da explicação, neste momento, passa a ser
influenciada também por esse nó (Tabela 15).
Bloco-Código Explicação Avaliação (do STI)
getchar() dividir precisão dados enquanto subtrair ponteiro dividir multiplicar digitar executar curto sem atribuir
Entendimento aproximado da língua natural: dividir {divid: N, f} precisão {precisã: N, f} dados {dad: N, f} enquanto {enquant: CONJSUB, d} subtrair {subtra: ?, f} ponteiro {ponteir: ?, f} dividir {divid: N, f} multiplicar {multiplic: VTD, f} digitar {digit: N, v} executar {execut: VINT, f} curto {curt: ADJ, f} sem {sem: PREP, d} atribuir {atribu: VBI+PPOA, f} Índice de lexemas reconhecidos: 0.23076923076923073 Mapeamento: (getchar v), Classificador: getchar 1.0 true Avaliação: 0.23076923076923073 Faixas: 0.0 - 1.0 Classificação: I - Incompleta AutoExplC: Você está no caminho certo. Mas, por favor, complete a explicação.
Tabela 15: Atuação do nó para identificação do contexto da explicação
5.2. Análise da Avaliação Final
A primeira preocupação ao analisar os resultados obtidos foi observar o
comportamento do STI com a adoção do nó adicional à Rede Bayesiana, com o
objetivo de melhorar o desempenho do mesmo perante as explicações solicitadas
apenas sobre um determinado comando da linguagem “C”. Apesar de não
conseguir sanar por completo a questão da determinação do contexto,
comparando os resultados descritos na Tabela 11 com os resultados anteriores
mostrados na Tabela 9, considerando a coluna das classificações corretas
obtidas, houve um aumento para a casa de 94,77% da precisão do tutor.
Observando os valores relativos à média, ou seja, a porcentagem de
68
classificações satisfatórias do STI frente ao esperado, notou-se uma pequena
melhora, aumentando de 92,27% na avaliação preliminar (Tabela 9) para 94,77%
na avaliação final (Tabela 11) aproximando-se do valor da mediana 95,84%
(Tabela 11), valor este que consiste na medida de localização do centro da
distribuição dos valores das médias obtidas nos níveis 1, 2 e 3.
Outro parâmetro significativo está relacionado à redução do desvio
padrão de 8,44% na avaliação preliminar (Tabela 9) para 5,20% na avaliação final
(Tabela 11), valor este que é baseado nos desvios em torno da média aritmética e
que leva em consideração a totalidade dos valores em estudo, consistindo em um
indicador de variabilidade bastante estável.
Concluindo, é relevante também mostrar a redução do intervalo de
confiança de 0,0003276 (Tabela 9) para 0,0001364 (Tabela 11), o qual expressa
o conceito que existe um determinado nível de confiança em que a média se
encontra dentro do intervalo.
Outra importante consideração está relacionada à grande diferença na
classificação das questões incompletas por parte do STI em relação ao esperado.
Neste caso, é necessário observar que um lexema “enquanto”, por exemplo, ao
ser encontrado, é mapeado para o comando “while” da Linguagem “C”. Este
mapeamento, por sua vez, pode produzir um determinado peso na Rede
Bayesiana. Por outro lado, o comando “while” é composto por um segundo
componente que representa a condicional. Neste caso, quando se encontra uma
explicação que não tem nada a ver com a condição esperada, o STI apenas irá
considerá-la como não observada perante aos nós da Rede Bayesiana. Porém, o
comando “while” já observado anteriormente irá influenciar uma possível
classificação incompleta por parte do STI, independente do que foi observado no
69
restante da explicação. Considerando, por outro lado, o ponto de vista de um
especialista humano, este consideraria a explicação errada, pois apesar do
estudante ter explicado uma parte dos comandos necessários, esta explicação
ocorreu fora do contexto da atividade proposta.
5.2.1 Análise das Respostas Erradas
Uma vez constatado o funcionamento global do STI, a análise é
concentrada sobre o conjunto de 25 explicações erradas do nível 3, geradas por
um especialista humano. Conforme mostrado na Tabela 16, o STI conseguiu
classificar corretamente 88% das explicações submetidas.
Esperado Respostas Obtidas Errada Correta Incompleta Errada Total Geral 25 1 2 22
Média 100,00% 4,00% 8,00% 88,00% Tabela 16: Avaliação Final – Respostas Erradas do Nível 3
Neste caso é importante observar a existência de uma explicação
incorreta, mas que o STI analisou como correta (Tabela 17). O problema,
conforme detalhado a seguir, é provocado pela questão da não identificação do
contexto da explicação.
Este problema ocorre quando a explicação concentra-se sobre um
único comando, ou seja, é utilizado apenas um nó da Rede Bayesiana para o
componente da explicação o que provoca, uma vez observado esse nó, a
classificação como correta. É importante salientar também, que para este caso,
o índice de lexemas reconhecidos foi de 66,66%, ou seja, o lexema “teclado” foi
mapeado e o lexema “o”, por ser um artigo, foi desconsiderado. Este índice, que
está acima dos 55%, faz com que o nó para identificação do contexto não seja
70
considerado como observado, não influenciando, desta forma, na classificação da
explicação pelo STI.
Bloco-Código Explicação Avaliação (do STI)
getchar() apagar o teclado Entendimento aproximado da língua natural: apagar {apag: VTD, f} o {o: ART, d} teclado {tecl: N, v} Índice de lexemas reconhecidos: 0.6666666666666667 Mapeamento: (getchar v), Classificador: getchar 1.0 true Avaliação: 1.0 Faixas: 0.0 - 1.0 Classificação: C - Correta AutoExplC: Parabéns!
Tabela 17: Explicação que foi classificada de forma equivocada
5.2.2. Avaliação das Respostas Incompletas
A Tabela 18 mostra a síntese do comportamento do STI em relação às
explicações incompletas e concentrou-se sobre a amostra das 25 explicações
(incompletas) presentes no nível 3.
Esperado Respostas Obtidas Incompleta Correta Incompleta Errada Total Geral 25 4 13 8
Média 100,00% 16,00% 52,00% 32,00% Tabela 18: Avaliação Final – Respostas Incompletas
Nesta análise, na qual o STI obteve uma precisão de 52,00%, serão
consideradas as quatro explicações que foram classificadas como corretas
(Tabela 19).
71
Item Bloco-Código Explicação Avaliação (do STI) A while (ch != ‘A’)
ch = getchar(); enquanto ch diferente de A
Entendimento aproximado da língua natural: enquanto {enquant: CONJSUB, d} ch {ch: VAR, v} diferente {diferent: ADJ, v} de {de: PREP, d} A {A: VAR, v} Índice de lexemas reconhecidos: 1.0 Mapeamento: (while v), (ch v), (!= v), (A v), (ch v), (= f), (getchar f), Classificador: while 0.444444444444444 true ch != ‘A’ 0.444444444444444 true ch = getchar 0.111111111111111 false Avaliação: 0.888888888888889 Faixas: 0.08333333333333333 - 0.75 Classificação: C - Correta AutoExplC: Parabéns!
B getchar() Ler Entendimento aproximado da língua natural: ler {ler: VTD, v} Índice de lexemas reconhecidos: 1.0 Mapeamento: (getchar v),
Classificador: getchar 1.0 true Avaliação: 1.0 Faixas: 0.0 - 1.0 Classificação: C - Correta AutoExplC: Parabéns!
C break Sair Entendimento aproximado da língua natural: sair {sair: VTI, v} Índice de lexemas reconhecidos: 1.0 Mapeamento: (break v), Classificador: break 1.0 true Avaliação: 1.0 Faixas: 0.0 - 1.0 Classificação: C - Correta AutoExplC: Ótimo é isso mesmo.
D pont_vetor++; incrementar pont_vetor
Entendimento aproximado da língua natural: incrementar {increment: ?, v} pont_vetor {pont_vetor: VAR, v} Índice de lexemas reconhecidos: 1.0 Mapeamento: (pont_vetor v), (++ v), Classificador: pont_vetor ++ 1.0 true Avaliação: 1.0 Faixas: 0.0 - 1.0 Classificação: C - Correta AutoExplC: Correto! Por favor, responda a próxima questão.
Tabela 19: Explicações incompletas classificadas como corretas
72
Analisando o primeiro caso: “while (ch != ‘A’) ch = getchar();” (Item A),
foi considerado um peso “desejável” para o trecho “ch =getchar()” (Figura 12) o
que determina que o STI dará uma maior importância aos componentes do
comando de repetição (Figura 13), os quais uma vez observados, farão com que
a explicação seja considerada correta, independente da mesma não realizar
referências ao trecho restante.
Figura 12: Cadastro dos pesos dos componentes da atividade proposta
Observando a explicação “enquanto ch diferente de A” existente na
Tabela 19, os lexemas “enquanto”, “ch”, “diferente” e “A” foram mapeados,
produzindo na saída da Rede Bayesiana um valor superior a 75%, que, para esta
atividade, é o valor mínimo para a explicação ser classificada como correta. Desta
forma, devido à atribuição dos pesos para os componentes da explicação (Figura
13), torna-se desnecessário explicar a linha de comando “ch = getchar();” para a
explicação ser considerada correta.
As demais explicações classificadas de forma equivocada referem-se
novamente à dificuldade da determinação do contexto para explicações
solicitadas sobre um único componente da linguagem, a qual já foi discutida
anteriormente.
73
Figura 13: Componentes da explicação e respectivos pesos
É importante salientar que a grande dificuldade do STI encontra-se na
classificação deste tipo de explicação, pois, a correta determinação do contexto
da explicação é crucial para uma adequada classificação. Esta atividade, para um
especialista humano, é relativamente simples, porém consiste em um grande
desafio para o processamento da língua natural, sendo ainda mais agravada pela
utilização de abordagens simplificadas, como a análise semântica latente,
adotada no STI sob discussão.
5.2.3. Avaliação das Respostas Corretas
Com relação à avaliação das respostas corretas, é possível observar
na Tabela 20 que o módulo de entendimento aproximado da língua natural
conseguiu classificá-las corretamente em 18 das 25 (72%) atividades propostas.
Outro ponto relevante consiste no fato que nenhuma das explicações foi
considerada errada pelo STI.
Esperado Respostas Obtidas Correta Correta Incompleta Errada Total Geral 25 18 7 0
Média 100,00% 72,00% 28,00% 0,00% Tabela 20: Avaliação Final – Análise Corretas
A análise a seguir é detalhada sobre as sete explicações que foram
classificadas como incompletas (Tabelas 21, 22, e 23).
while
ch != ‘A’
ch = getchar
avaliação
Peso: 0,44444
Peso: 0,44444
Peso: 0,11111
74
Observando os itens A e F mostrados nas Tabelas 21, 22 e 23, nota-se
que o não entendimento ocorreu devido a uma falha na construção do módulo do
mapeador de comandos que, nestas atividades, não conseguiu identificar a
utilização de vetores. Por outro lado, nos itens C e D (Tabelas 21, 22 e 22), a
falha ocorreu devido à existência de ambigüidade no operador para ponteiros “*”
em relação ao operador de multiplicação. Neste caso, novamente, o problema
ocorreu no mapeador de comandos.
Item Bloco-Código Explicação Avaliação (do STI) A int v[5] = { 4, 3, 8, 2, 1}; declarar uma
variável vetor de inteiros, v e inicializar com os valores 4, 3, 8, 2, 1
Entendimento aproximado da língua natural: declarar {declar: VINT, v} uma {uma: ART, d} variável {variável: ?, v} vetor {vetor: ?, v} de {de: PREP, d} inteiros {inteir: ADJ, v} v {v: VAR, v} e {e: CONJCOORD, d} inicializar {inicializ: ?, v} com {com: PREP, d} os {os: ART, d} valores {valor: N, d} 4 {4: VAR, v} {: PREP, d} 3 {3: VAR, v} {: PREP, d} 8 {8: VAR, v} {: PREP, d} 2 {2: VAR, v} {: PREP, d} 1 {1: VAR, v} Índice de lexemas reconhecidos: 1.0 Mapeamento: (int v), (v v), (5 f), (= f), (4 v), (3 v), (8 v), (2 v), (1 v), Classificador: int 0.5 true v[5] = 4 3 8 2 1 0.5 false Avaliação: 0.5 Faixas: 0.0 - 1.0 Classificação: I - Incompleta AutoExplC: Você está no caminho certo. Mas, por favor, complete a explicação.
B default executar este bloco padrão
Entendimento aproximado da língua natural: executar {execut: VINT, f} este {este: PD, f} bloco {bloc: N, f} padrão {padrã: N, v} Índice de lexemas reconhecidos: 0.25 Mapeamento: (default v), Classificador: default 1.0 true Avaliação: 0.25 Faixas: 0.0 - 1.0 Classificação: I - Incompleta AutoExplC: Por favor, complete a explicação
Tabela 21: Explicações incorretamente classificadas pelo STI
75
Item Bloco-Código Explicação Avaliação (do STI) C int *pont_vetor; declarar a
variável ponteiro para inteiros pont_vetor
Entendimento aproximado da língua natural: declarar {declar: VINT, v} a {a: PREP, d} variável {variável: ?, v} ponteiro {ponteir: ?, v} para {par: PREP, d} inteiros {inteir: ADJ, v} pont_vetor {pont_vetor: VAR, v} Índice de lexemas reconhecidos: 1.0 Mapeamento: (int v), (* f), (pont_vetor v), Classificador: int 0.5 true * pont_vetor 0.5 false Avaliação: 0.5 Faixas: 0.0 - 1.0 Classificação: I – Incompleta AutoExplC: Você está no caminho certo. Mas, por favor, complete a explicação.
D while (*pont_vetor != 0) { pont_vetor++; }
enquanto o conteúdo do ponteiro pont_vetor for diferente de 0 incrementar o endereço do ponteiro
Entendimento aproximado da língua natural: enquanto {enquant: CONJSUB, d} o {o: ART, d} conteúdo {conteúd: N, v} do {do: PREP+ART, f} ponteiro {ponteir: ?, v} pont_vetor {pont_vetor: VAR, v} for {for: VLIG, f} diferente {diferent: ADJ, v} de {de: PREP, d} 0 {0: VAR, v} incrementar {increment: ?, v} o {o: ART, d} endereço {enderec: N, f} do {do: PREP+ART, f} ponteiro {ponteir: ?, v} Índice de lexemas reconhecidos: 0.7333333333333334 Mapeamento: (while v), (* f), (pont_vetor v), (!= v), (0 v), (pont_vetor v), (++ v), Classificador: while 0.333333333333333 true * pont_vetor != 0 0.333333333333333 false pont_vetor ++ 0.333333333333333 true Avaliação: 0.6666666666666667 Faixas: 0.0 - 1.0 Classificação: I - Incompleta AutoExplC: Por favor, complete a explicação
Tabela 22: Continuação da Tabela 21
76
Item Bloco-Código Explicação Avaliação (do STI) E pont_vetor++; incrementar o
endereço do ponteiro pont_vetor
Entendimento aproximado da língua natural: incrementar {increment: ?, v} o {o: ART, d} endereço {enderec: N, f} do {do: PREP+ART, f} ponteiro {ponteir: ?, f} pont_vetor {pont_vetor: VAR, v} Índice de lexemas reconhecidos: 0.5 Mapeamento: (pont_vetor v), (++ v), Classificador: pont_vetor ++ 1.0 true Avaliação: 0.5 Faixas: 0.0 - 1.0 Classificação: I – Incompleta AutoExplC: Por favor, complete a explicação
F printf("%f, ", v[i]); imprimir o valor do elemento do vetor v com índice i, utilizando uma máscara %f
Entendimento aproximado da língua natural: imprimir {imprim: VTI+PPOA, v} o {o: ART, d} valor {valor: N, f} do {do: PREP+ART, f} elemento {element: N, f} do {do: PREP+ART, f} vetor {vetor: ?, f} v {v: VAR, v} com {com: PREP, d} índice {índic: N, f} i {i: VAR, v} {: PREP, d} utilizando {utiliz: VTD, f} uma {uma: ART, d} máscara {másc: N, f} %f {%f: CON, v} Índice de lexemas reconhecidos: 0.5 Mapeamento: (printf v), (%f, v), (v v), (i v), Classificador: printf 0.5 true "%f, " v[i] 0.5 true Avaliação: 0.5 Faixas: 0.0 - 1.0 Classificação: I - Incompleta AutoExplC: Por favor, complete a explicação
G void declarar uma função que retorna nada
Entendimento aproximado da língua natural: declarar {declar: VINT, f} uma {uma: ART, d} função {funçã: N, f} que {que: PR, f} retorna {retorn: VTI, f} nada {nad: PIND, v} Índice de lexemas reconhecidos: 0.33333333333333337 Mapeamento: (void v), Classificador: void 1.0 true Avaliação: 0.33333333333333337 Faixas: 0.0 - 1.0 Classificação: I - Incompleta AutoExplC: Por favor, complete a explicação
Tabela 23: Continuação da Tabela 22
77
Nos itens B, E e G mostrados nas Tabelas 21, 22 e 23, o problema
ocorreu devido à inclusão de um nó à Rede Bayesiana para tentar minimizar o
problema do STI não conseguir identificar o contexto em atividades que solicitam
a explicação de apenas um comando da linguagem. Nestas três atividades,
apesar do STI conseguir identificar a existência dos lexemas esperados para a
explicação, o peso do nó utilizado para identificar o contexto fez com que, em
todos os casos, as explicações fossem classificadas como incompletas.
6. CONCLUSÃO
79
O presente trabalho é dividido em várias etapas. Inicialmente é
realizada a revisão bibliográfica sobre auto-explicação de exemplos e STIs. Esta
etapa inicial permite uma concepção prévia do modelo do STI que foi proposto.
Em um segundo momento, os esforços são concentrados na pesquisa para
determinar a forma de representação do conhecimento que foi adotada no STI, a
terceira etapa é o estudo e a definição de como realizar o processamento da
língua natural. A última etapa consistiu no processo de avaliação do STI e a
análise dos resultados obtidos.
As pesquisas em STI apresentam uma grande preocupação
relacionada com a construção de ambientes que possibilitem um aprendizado
mais eficiente. Outro fator relevante consiste na interação entre aluno e tutor que,
cada vez mais, procura se aproximar da interação aluno-professor, tornando o STI
uma extensão da sala de aula e fazendo com que esta interação ocorra de
maneira mais natural possível.
Por outro lado, o desenvolvimento de STIs apresenta uma série de
dificuldades e desafios, entre os quais pode-se salientar a representação do
conhecimento, o entendimento da língua natural e a avaliação, por parte do STI,
da explicação gerada pelo aluno.
Além da escolha da representação do conhecimento, é importante
também observar o grande volume de trabalho que é necessário para mapear o
conhecimento de um especialista humano para uma base de conhecimento.
Técnicas de processamento da língua natural permitem grandes avanços nesta
interação, porém ainda apresentam um alto grau de dificuldade na sua
implementação. Dentro deste contexto a abordagem da análise semântica latente
(WIEMER-HASTINGS et al, 1999), utilizada no tutor proposto nesta dissertação,
80
apresenta bons resultados em domínios que podem ser representados através de
um conjunto restrito de lexemas. A adoção desta técnica facilitou de maneira
significativa o processo de implementação do módulo de entendimento
aproximado da língua natural e, como analisado anteriormente, apresentou
resultados satisfatórios, conforme sintetizado na Tabela 24.
Considerando o desempenho global do STI no Nível 3 (Tabela 24), ou
seja, analisando o desempenho do STI em relação às explicações criadas por um
especialista humano, pode-se observar uma precisão média de 70,67% na
avaliação adequada das explicações, estando esse valor próximo à mediana
72%. Por outro lado, os valores elevados no desvio padrão (18,04%) e no
intervalo de confiança (0,013576) são influenciados, em grande parte, pela
dificuldade apresentada pelo STI na classificação das explicações incompletas,
fato este, já discutido anteriormente no item 5.2.2.
Amostra Média ObtidaErrada 88,00%Incompleta 52,00%Correta 72,00%
Média 70,67%Mediana 72,00%
Desvio Padrão 18,04%Invervalo de Confiança 0,013576
Tabela 24: Síntese dos resultados obtidos na avaliação final em relação ao Nível 3
Considerando a avaliação, por parte do STI, das explicações geradas,
a adoção de técnicas de raciocínio probabilístico mostraram-se acertadas pois
conseguem trabalhar com razoável precisão dentro de um ambiente que muitas
vezes recebe dados incertos ou imprecisos, pois não é possível deixar de lado o
fato do aluno estar em processo de aprendizado e que fatores de incerteza
estejam sempre presentes dentro deste contexto.
81
Algumas das limitações observadas no STI podem ser abordadas em
trabalhos futuros, dentre os quais é relevante citar:
• Um estudo mais aprofundado sobre as faixas ideais para classificação
das explicações poderia aumentar sensivelmente a precisão do STI
referente à classificação das respostas incompletas.
• A implementação de melhorias no módulo mapeador de comandos da
linguagem “C”, além de uma possível integração do tutor com um
compilador da linguagem “C”, permitiria a melhoria na classificação das
explicações por parte do STI e também possibilitaria ampliar o escopo
de atuação do STI, permitindo extrapolações e simulações de
alterações efetuadas sobre o código-fonte.
• Investigação sobre o uso do Raciocínio Baseado em Casos como
alternativa para tentar aumentar a precisão do STI na classificação das
explicações.
• Necessidade do aprimoramento do próprio módulo de entendimento
aproximado da língua natural dando uma ênfase maior à questão da
análise semântica ao invés da técnica de análise semântica latente
utilizada neste STI.
7. REFERÊNCIAS
83
AIRES, R. V. X. Implementação, Adaptação, Combinação e Avaliação de Etiquetadores para o Português do Brasil. 2000. Dissertação (Mestrado) - Instituto de Ciências Matemáticas e de Computação de São Carlos, Universidade de São Paulo, São Carlos, 2000. Disponível em: <http://www.nilc.icmc.usp.br/nilc/pessoas/rachelport.htm>. Acesso em: 10 de maio de 2005.
ALEVEN, V.; POPESCU, O.; KOEDINGER, K. Towards tutorial dialog to support
self-explanation: Adding natural language understanding to a cognitive tutor. In: INTERNATIONAL CONFERENCE ON AI AND EDUCATION, 10., 2001. Anais 10th International Conference on AI and Education. Disponível em: <http://citeseer.nj.nec.com/ 510868.html>. Acesso em: 10 de novembro 2003.
ANDERSON, J. R.; CORBETT, A. T.; KOEDINGER, K. R.; PELLETIER, R.
Cognitive tutors: Lessons learned. The Journal of the Learning Sciences, n.4, p.167–207, 1995. Disponível em: <http://act-r.psy.cmu.edu/papers/ Lessons_Learned.html>. Acesso em: 3 de maio de 2005.
BHATNAGAR, R. K.; KANAL, L. N. Handling Uncertain Information: A Review of
Numeric and Non-numeric Methods In: KANAL, L.N.; LEMMER, J.F. Uncertainty in Artificial Intelligence. Amsterdam: Elsevier Science, 1986.
BRUSILOVSKY, P.; SCHWARZ, E.; WEBER, G. ELM-ART: An intelligent tutoring
system on World Wide Web. In: FRASSON, C.; GAUTHIER, G.; LESGOLD, A. Intelligent Tutoring Systems. Berlin: Springer Verlag, 1996. v.1086, p.261-269.
CHI, M. T. H.; BASSOK, M.; LEWIS, M. W.; REIMANN, P.; GLASER, R. Self-
explanations: How students study and use examples to solve problems. Cognitive Science, n.13, p.145-182, 1989. Disponível em: <http://www.pitt. edu/~chi/papers/ChiBassokLewisReimannGlaser.pdf>. Acesso em: 30 de setembro de 2003.
CHI, M. T. H.; DE LEEUW, N.; CHIU, M.; LA VANCHER, C. Eliciting self-
explanations improves understanting. Cognitive Science, n.18, p.439-477, 1994. Disponível em: <http://www.pitt.edu/~chi/papers/Self-explanations 94.pdf>. Acesso em: 17 de setembro de 2003.
CONATI, C.; LARKIN, J.; VANLEHN, K. A computer framework to suport self-
explanation. In: DU BOULAY B.; MIZOGUCHI R. In: ARTIFICIAL INTELLIGENCE IN EDUCATION, 8., 1997, Ohmsha. Anais 8th Artificial Intelligence in Education. Ohmsha: IOS Press, 1997.
CONATI, C.; VANLEHN, K. Teaching meta-cognitive skills: implementation and
evaluation of a tutoring system to self-explanation while learning from examples. In: LAJOIE, S. P.; VIVET, M. In: Artificial Intelligence in Education. Amsterdam: IOS Press, 1999. p.297-304.
84
CORBETT, A. T.; ANDERSON, J. R. LISP intelligent tutoring system: Research in skill acquisition. In: LARKIN, J. H.; CHABAY, R. W. Computer-assisted instruction and intelligent tutoring systems: Establishing communication and collaboration. Hillsdale, NJ: Erlbaum, 1992. p.73–110. Disponível em: <http://act-r.psy.cmu.edu/publications/pubinfo?id=167>. Acesso em: 10 de maio de 2005.
CORBETT, A. T.; BHATNAGAR, A. Student modeling in the ACT Programming
Tutor: Adjusting procedural learning model with declarative knowledge. In: JAMESON, A.; PARIS, C.; TASSO, C. User Modeling. New York,1997.
FREEDMAN, R.; ALI, S. S.; MCROY, S. What is an intelligent tutoring system? In:
Intelligence, v.11, n.3, p.15-16, 2000. Disponível em: <http://www.cs.niu. edu/~freedman/papers/link2000.ps>. Acesso em: 16 de setembro de 2003.
FREEDMAN, R.; ZHOU, Y.; GLASS, M.; KIM, J.; EVENS, M. Using rule induction
to assist in rule construction for a natural-language based intelligent tutoring system. In: ANNUAL CONFERENCE OF THE COGNITIVE SCIENCE SOCIETY, 20., 1998, Hillsdale, NJ. Anais 20th Annual Conference of the Cognitive Science Society. Hillsdale, NJ: Erlbaum, 1998, p. 362–367. Disponível em: <http://www.cs.iit.edu/~circsim/documents/ rfcog98.pdf>. Acesso em: 8 de maio de 2005.
GRAESSER, A. C; WIEMER-HASTINGS, K.; WIEMER-HASTINGS, P.; KREUZ,
R.; Tutoring Research Group. AutoTutor: A simulation of a human tutor. In: Journal of Cognitive Systems Research, n.1, p. 35-51, 1999.
HALL, P.; WOOD, P. Intelligent Tutoring Systems: A Review for Beginners. In:
Canadian Journal of Educational Communication, v.19, n.2, p.107-123, 1990.
HECKERMAN, D. A tutorial on learning bayesian networks. Technical Report: MSR-TR-95-06. Redmond: Microsoft Corporation, 1995.
JENSEN, V. Bayesian networks and decision graphs. Springer, 2001. JURAFSKY, D.; MARTIN, J. H. Speech and language processing. New Jersey:
Prentice-Hall, 2000. KOLODNER, J. Case based reasoning. San Mateo, CA: Morgan Kaufmann
Publishers, 1993. KONZEN, A.; FROZZA, R. Uma estratégia de ensino híbrida para sistemas
tutores inteligentes. In: SEMINÁRIO DE INICIAÇÃO CIENTÍFICA E JORNADA DE ENSINO, PESQUISA E EXTENSÃO DA UNIVERSIDADE DE SANTA CRUZ DO SUL, 5., 1999, Santa Cruz do Sul. Anais 5o Seminário de Iniciação Científica e Jornada de Ensino, Pesquisa e Extensão da Universidade de Santa Cruz do Sul. Santa Cruz do Sul: Universidade de Santa Cruz do Sul, 1999.
85
LANDAUER, T. K. On the computational basis of learning and cognition: Arguments from LSA. In: ROSS, N., The psychology of learning and motivation, v.1, p.43-84, 2002.
LIMA, D. R.; ROSATELLI, M. C. Um sistema tutor inteligente para um ambiente
virtual de ensino aprendizagem. In: CONGRESSO DA SOCIEDADE BRASILEIRA DA COMPUTAÇÃO, 23., 2003, Campinas. Anais 23o Congresso da Sociedade Brasileira de Computação. Campinas: UNICAMP, 2003. Disponível em: <http://www.ensinoweb.com.br/docs/ Artigo_STI.pdf>. Acesso em: 11 de maio de 2005.
LUSTOSA, V. G.; ALVARENGA, R. O estado da arte em inteligência artificial.
Colabor@ - Revista Digital da Comunidade Virtual de Aprendizagem da Rede das Instituições Católicas de Ensino Superior, v. 2, n. 8, 2004. Disponível em: <http://www.ricesu.com.br/colabora/n8/>. Acesso em 12 de fevereiro de 2005.
MCARTHUR, D.; LEWIS, M.; BISHAY, M. The roles of artificial intelligence in
education: current progress and future prospects. Santa Monica, CA: RAND, 1993.
MINSKY, M. A framework for representing knowledge. In: MIT-AI Laboratory
Memo, n.306, 1974. MURRAY, R. C.; VANLEHN, K. DT Tutor: A decision-theoretic, dynamic approach
for optimal selection of tutorial actions. In: GAUTHIER, G.; FRASSON, C.; VANLEHN, K. Intelligent Tutoring Systems. New York, 2000, p.153-162.
PEROTTO, F. S.; VICARI, R. M. Modelagem do conhecimento, sistemas
especialistas e o projeto SEAMED. In: Revista Eletrônica de Iniciação Científica, v.1, n.1. Sociedade Brasileira de Computação, 2001. Disponível em: <http://www.sbc.org.br/reic/edicoes/2001e1/>. Acesso em: 15 de abril de 2005.
POPESCU, O.; ALEVEN, V.; KOEDINGER, K. A knowledge-based approach to
understanding students’ explanations. In: CONFERENCE ON ARTIFICIAL INTELLIGENCE IN EDUCATION, 2003, Sidney, Austrália. Anais Conference on Artificial Intelligence in Education 2003. Sidney, Austrália, 2003. Disponível em <http://www.cs.usyd.edu.au/~aied/vol6/vol6_Popescu.pdf>. Acesso em: 18 de agosto de 2004.
PORTER, M. F. An algorithm for suffix stripping. In: Program, v.14, n.3, p.130-
137, 1980. Disponível em: <http://www.tartarus.org/~martin/PorterStemmer/> e <http://snowball.tartarus.org/>. Acesso em: 10 de maio de 2005.
86
REDMOND, M.; PHILLIPS, S. Encouraging self-explanation through case-based tutoring, a case study. In: INTERNATIONAL CONFERENCE ON CASE-BASED REASONING, 1997, Providence, Rhode Island. Anais International Conference on Case-Based Reasoning 1997. Providence, Rhode Island, 1997. p.132-144. Disponível em: <http://citeseer.nj.nec.com/ 133925.html>. Acesso em: 25 de agosto de 2003.
RICH, E.; KNIGHT, K. Inteligência Artificial. Makron Books, 1993, 722p. RUSSEL, S.; NORVIG, P. Artificial intelligence: A modern approach. New
Jersey: Prentice Hall, 1995. SIVIA, D. S. Data analysis: A bayesian tutorial. Oxford University Press, 1996. SCHWORM, S.; RENKL, A. Learning by solved example problems: Instructional
explanations reduce self-explanation activity. In: ANNUAL MEETING OF THE COGNITIVE SCIENCE SOCIETY, 24., 2002, Fairfax, Virginia. Anais 24th Annual Meeting of the Cognitive Science Society. Fairfax, Virginia: George Mason University, 2002. Disponível em: <http://cogsci.psy.utexas.edu/ confproc/gmu02/final_ind_files/schworm_renkl.pdf>. Acesso em: 3 de setembro de 2003.
SRIRAM, R. Intelligent systems for engineering: A knowledge-based
approach. New York: Springer-Verlag, 1997. TRAFTON, J.; REISER, B. The contributions of studying examples and solving
problems to skill acquisition. In: ANNUAL CONFERENCE OF THE COGNITIVE SCIENCE SOCIETY, 15., 1993. Anais 15th Annual Conference of the Cognitive Science Society. Disponível em: <http://citeseer. nj.nec.com/149956.html>. Acesso em: 10 de outubro de 2003.
VANLEHN, K. Analogy events: How examples are used during problem solving.
Cognitive Science, v.22, n.3, p.347-388, 1998. Disponível em: <http://www. pitt.edu/~vanlehn/distrib/VanLehnCogSci98.pdf>. Acesso em: 17 de setembro de 2003.
WEBER, G.; MÖLLENBERG, A. ELM-PE: A knowledge-based programming
environment for learning LISP. In: ED-MEDIA, 1994, Vancouver, Canadá. Anais ED-Media 1994. Vancouver, Canadá, 1994, p.557-562.
WEBER, G.; BRUSILOVSKY, M. S.; STENLE, F. ELM-PE: An intelligent
learning environment for programming. 1996. Disponível em: <http://www.psychologie. uni-trier.de:8000/projects/ELM/ELM-PE/tour.html>. Acesso em: 3 de outubro de 2003.
WIEMER-HASTINGS P.; WIEMER-HASTINGS, K.; GRAESSER, A. C.
Approximate natural language understanding for an intelligent tutor. In: American Association for Artificial Intelligence. Menlo Park, CA: AAAI Press. 1999. p.172-176. Disponível em: <http://internal.autotutor.org/papers/ approx.pdf>. Acesso em: 10 de maio de 2005.
87
WOOLF, B. P.; BECK, J.; ELIOT, C.; STERN, M. Growth and maturity of intelligent tutoring systems: A status report. In: FORBUS, K. D., FELTOVICH, P. J. Smart Machines in Education. Menlo Park, CA: AAAI Press. 2002. p.99-144.
ZHOU, Y.; FREEDMAN, R.; GLASS, M. Delivery hints in a dialogue-based
intelligent tutoring system. In: NACIONAL CONFERENCE ON ARTIFICIAL INTELLIGENCE, 16., 1999, Orlando. Anais 16th Nacional Conference on Artificial Intelligence. Orlando, 1999. Disponível em: <http://citeseer.nj.nec. com/zhou99delivering.html>. Acesso em: 16 de setembro de 2003.
APÊNDICES
89
A. Estrutura das Relações
Exemplo Campo Tipo de Dados Tamanho Descrição
Numero Inteiro 11 É a chave primária, recebe um número inteiro automaticamente durante o cadastro.
Descrição Caracter 255 Descrição do problema formulado pelo professor.
Resolução Memorando - Código-fonte com a resolução do problema.
Mapeador
Campo Tipo de Dados Tamanho Descrição Tipo Caracter 25 Tipo do componente: comando,
atribuição, expressão, operadores lógicos ou aritméticos.
Comando Caracter 50 Primitiva da Linguagem “C” que representa o comando.
Sintaxe Caracter 255 Sintaxe esperada. Terminador Caracter 1 Caracter que representa o
terminador do comando, normalmente ponto-e-vírgula, mas em alguns casos dois pontos (case) ou nenhum (do).
Número-Componente Inteiro 2 Número de componentes que formam a instrução.
Deslocamento Inteiro 2 Indica a partir de que componente a instrução deve ser composta.
Lexema Memorando - Lexemas, da língua portuguesa, que permitem mapear a respectiva instrução, apresentando-se etiquetados como essenciais ou opcionais.
Explicação
Campo Tipo de Dados Tamanho Descrição
Número-Exemplo
Inteiro 11 Número do exemplo ao qual a explicação está relacionada.
Número Inteiro 11 Número da explicação gerado automaticamente durante o cadastro.
Mensagem Memorando - Texto formulado pelo professor, que será apresentado para orientar o aluno durante a explicação.
Seleção-Ínicio Inteiro 11 Posição de início, em termos de caracter, do trecho do código-fonte.
Seleção-Término Inteiro 11 Posição de término. Número-Tópico Inteiro 11 Número do tópico com o qual a
explicação se relaciona.
90
Peso-Explicação Campo Tipo de
Dados Tamanho Descrição
Número-Exemplo Inteiro 11 Número do exemplo relacionado. Número-Explicação Inteiro 11 Número da explicação relacionada. Seleção-Início Inteiro 11 Posição de início, em termos de
caracter, do componente dentro do código-fonte.
Seleção-Término Inteiro 11 Posição de término. Componente Caracter 255 Componente da instrução. Importância Inteiro 1 Importância do componente da
explicação dentro do contexto geral, sendo convencionado o valor 4 para essencial, 2 para necessária e 1 para desejável.
Peso Ponto Flutuante
17,15 Peso do componente dentro do contexto geral da explicação.
Corpus
Campo Tipo de Dados Tamanho Descrição Lexema Caracter 50 Contém o lexema. Etiqueta Caracter 50 Etiqueta atribuída ao lexema. Ocorrência Inteiro 6 Número de ocorrências do conjunto
lexema-etiqueta dentro do corpus. É utilizada para determinar, quando ocorre ambigüidade, a maior probabilidade de uso do lexema.
Etiqueta
Campo Tipo de Dados Tamanho Descrição Identificador Caracter 25 Conteúdo da etiqueta. Descrição Caracter 50 Descrição do conteúdo da etiqueta. Ignorar Caracter 1 Determina se um lexema etiquetado com
este identificador deve, ou não, ser considerando na determinação do conteúdo da frase.
Progresso
Campo Tipo de Dados Tamanho Descrição Código-Aluno Caracter 10 Código do aluno. Número-Tópico Inteiro 11 Número do tópico. Número-Exemplo
Inteiro 11 Número do exemplo ao qual se refere a atividade.
Número-Explicação
Inteiro 11 Número da atividade.
Tentativa Inteiro 11 Quantidade de tentativas realizadas pelo aluno nesta atividade.
Bloco-Código Memorando - Trecho do programa que deverá ser explicado.
Explicação Memorando - Explicação gerada pelo aluno. Avaliação Memorando - Avaliação da explicação pelo STI. Situação Caracter 1 Classificação gerada pelo STI, a partir
da avaliação. Pode ser: C- Correta, I – Incompleta e E – Errada.
Data-Início Data-Hora - Data e horário em que o aluno iniciou a resolução da atividade.
Data-Término Data-Hora - Data e horário em que o aluno terminou a resolução da atividade.
91
B. Atividades Propostas para a Avaliação do STI
Neste apêndice são mostradas as 25 atividades que foram utilizadas
para a avaliação do STI. Onde a coluna número mostra o número da atividade
proposta, a coluna bloco de código contém o trecho do código-fonte que o aluno
irá explicar.
Na coluna componente são exibidos os componentes da atividade que
irão compor os nós da Rede Bayesiana, sendo que as próximas colunas
representam, respectivamente, o grau de importância e o peso associado a cada
nó.
Número Bloco de Código Componente Importância Peso
int Essencial 0,333333y = 5 Necessária 0,166667int Essencial 0,333333
1
int y = 5; int z = x + y; z = x + y Necessária 0,166667
printf Necessária 0,3333332
printf("soma: %d", z); "soma: %d", z Essencial 0,666667
if Necessária 0,3333333
if (x % 2) x % 2 Essencial 0,666667
while Essencial 0,285714i < y Essencial 0,285714i ++ Essencial 0,285714
4
while(i<y) { i++; r*=x; } r *= x Necessária 0,142857
if Essencial 0,25a > 5 Essencial 0,25c = a + b Necessária 0,125else Essencial 0,25
5
if (a > 5) c = a + b; else c = a - b; c = a - b Necessária 0,125
if Essencial 0,4v[i] > maior Essencial 0,4
6
if (v[i] > maior) maior = v[i]; maior = v[i] Necessária 0,2
int Essencial 0,57
int v[5] = { 4, 3, 8, 2, 1}; v[5] = 4 3 8 2 1 Essencial 0,5
int Essencial 0,88
int maior = 0; maior = 0 Desejada 0,2
9 ch = 0; ch = 0 Essencial 1
92
Número Bloco de Código Componente Importância Peso while Essencial 0,444444ch != A Essencial 0,444444
10
while (ch != A) ch = getchar(); ch = getchar Desejada 0,111111
11 getchar() getchar Essencial 112 i += 2; i += 2 Essencial 1
while Essencial 0,513
while (i <= 10) i <= 10 Essencial 0,5
14 Break Break Essencial 115 default default Essencial 1
Scanf Essencial 0,516
scanf ("%d", &n); "%d", &, n Essencial 0,5
for Essencial 0,190476int i = 0 Desejada 0,047619i < 3 Essencial 0,190476i ++ Essencial 0,190476auxiliar[j] = vetor[i] Essencial 0,190476
17
for (int i = 0; i < 3; i++) { auxiliar[j] = vetor[i]; j--; } j -- Essencial 0,190476
int Essencial 0,518
Int auxiliar[3]; auxiliar[3] Essencial 0,5
int Essencial 0,519 int *pont_vetor; * pont_vetor Essencial 0,5
while Essencial 0,333333* pont_vetor != 0 Essencial 0,333333
20
while (*pont_vetor != 0) { pont_vetor++; } pont_vetor ++ Essencial 0,333333
21 pont_vetor++; pont_vetor ++ Essencial 1return Essencial 0,522
Return (0); 0 Essencial 0,5
if Essencial 0,333333v[j] < v[menor] Essencial 0,333333
23
if (v[j] < v[menor]) menor = j; menor = j Essencial 0,333333
printf Essencial 0,524
printf("%f, ", v[i]); "%f, " v[i] Essencial 0,5
25 Void void Essencial 1
93
C. Explicações Utilizadas na Avaliação do STI
Conjunto de explicações que foram utilizadas para realizar a avaliação
do STI, sendo importante observar que no Nível 1 e 2 as explicações em sua
totalidade são consideradas erradas e foram geradas automaticamente através de
lexemas existentes no Corpus (Nível 1) e lexemas suportados pelo mapeador de
comandos da linguagem “C” (Nível 2).
No nível 3 as explicações foram geradas por um especialista humano
no domínio de atuação do STI e consistem em 75 explicações igualmente
divididas entre corretas, incompletas e erradas.
# Nível 1 # AutoExplC - Arquivo para avaliação do módulo do aluno # Geração automática de frases com palavras existentes no corpus # provém destruídos Continuava transformar-se bananeiras torno serrana onda tempos planta sotaque engano emboscada solo incorporou ficoeritrina longe descarregam acusando pereiras vigilantes progride Oviedo brizanta acontecia Waldir cai encolhia Real mascate invaginações ternura diacinese milharal deserto engordando Berta confundir coxilhas trombeta Ristovski preta desmatamento renovados Stuart regra Bloch medir dúvida davam colesterol tramitação moitas Atravessamos ligada contentava fazia consolo principalmente Vieram morrem convenceu ativa saracoteando orientados transpassado imprimia-lhe forrageira adapta recomenda-se ética mover extingue examine exatamente Donner percebemos para assinados dissolução soltamos isso efeito terceirizando improvisei sedentária Aspásia seguro resultaram trocou bombardear forrada fomento atletismo gramíneas aeróbico Congresso sucedendo-se Bank tomei envoltório arcos trabalhado cristal ambos penetra embarcou lua bacterioclorofila mistério gerada caracteres cousa assessores tentava atrapalhado reclamou duque verbo feitiços amealhando Legislativa anuncia denota influencia fora improvisou-se flagrante baixo Exclamou operando utilizadas transformar aprimorar africano ferver devagar surpreender-se valsa divulgaria passarem retraiu-se ritual garota milagre atinja cego sofriam basta plumas criadeira converteu-se cardiovasculares bateu passou brandamente intercalar cobertura esvaía-se-me estratégicos devendo caseira ilustra bagas possível podem chorar rachados Ipanema dessa ficar deixou preparando felicíssimo sermões superávit melancia quantia uva argumentos Albert princípio parecia União tropa adapta aristocráticas fenação conflitos estabilidade situação meia arregaça-lhe imediatamente friamente trata paralelo horizontes analisada constitui milagre deve-se porteiro sobreviventes minimetralhadoras continuou transação atestam sa tablóide vista quiasmas camaradas peito frigoríficos isolado Jumil incêndio acompanhar abrir embelezamento excomungado escaramuçar tréguas protistas chocou altar Ademar separar-se o felá agora fezes Haddad escritório cartão levantou tomam Unicamp Lourenço qualquer mujique permitindo deposto desembarque fim condicionamento andar Pereira melhoramento trocara missionários capins cego sofriam basta plumas criadeira peito sucedendo-se Bank tomei forrada fomento atletismo desmatamento renovados Stuart regra Bloch medir dúvida davam colesterol verbo feitiços amealhando Legislativa acompanhar abrir embelezamento # # Nível 2 # AutoExplC - Arquivo para avaliação do módulo do aluno # Geração automática de frases apenas com lexemas suportados pelo mapeador de comandos “C” # enumerar definir endereço estrutura para constante vazio criar para caracter nulo inicializar subtrair ponteiro continuar testar enumerar multiplicar enquanto selecione vazio acumular decrementar incrementar sinal constante dupla sem verificar resto sair volátil conteúdo teclado verificar dividir dados exibir multiplicar dividir volátil subtrair superior
94
dividir precisão dados enquanto subtrair ponteiro dividir multiplicar digitar executar curto sem atribuir caso união contrário adicionar somar menor decrementar enquanto decrementar inicializar para enquanto enquanto outra iniciar constante para ou definir número dados superior estático subtrair inteiro multiplicar nulo inicializar sinal caso divisão iniciar absoluto união atribuir realizar sinal vetor menor vazio superior caso receber enquanto ler realizar exterior atribuir saltar não voltar número incrementar ou variável inicializar tipo externo padrão imprimir senão estrutura seleção prosseguir nulo estático dividir voltar inferior constante somar registro diferente inferior absoluto nada devolver digitar registro menor registro divisão vazio inicializar vazio declarar absoluto somar absoluto número obter seleção subtrair testar senão nada registro tamanho imprimir dividir que igual relacionar variável caso multiplicar outra vetor caso listar contrário precisão realizar registro tamanho igual dados atribuir para união executar número estrutura flutuante quando multiplicar atribuir tamanho sinal criar volátil criar enquanto quando definir inverso exterior multiplicar padrão multiplicar digitar vazio ponteiro devolver enquanto constante selecione listar contrário precisão realizar atribuir inicializar para para ou definir número estático subtrair superior dividir precisão dados enquanto subtrair flutuante superior dividir precisão multiplicar contrário vetor caso precisão listar realizar # # Nível 3 # AutoExplC - Arquivo para avaliação do módulo do aluno # Frases geradas por um especialista humano, dentro do contexto dos exercícios propostos. # # 1. int y = 5; int z = x + y; declarar e atribuir valores as variáveis inteiras y e z declarar as variáveis inteiras y e z, atribuir 5 a y e o valor x mais y a variável z eliminar a variável inteira y e z # 2. printf("soma: %d", z); imprimir z imprimir a variável inteira z e a string soma apagar a string soma e o valor de z # 3. if (x % 2) testar o resto da divisão verificar o resto da divisão de x por 2 obter o resultado da multiplicação de x por 2 # 4. while(i<y) { i++; r*=x; } enquanto i menor que y acumular i enquanto i menor que y acumular i, fazer com que r receba a multiplicação de r por x evitar que a variável i fique negativa # 5. if (a > 5) c = a + b; else c = a - b; se a maior que 5 então c deve receber a mais b quando a maior que 5, c receberá a mais b, caso contrário c receberá a menos b. enquanto a é menor que 5, c deve receber a multiplicação de a e b # 6. if (v[i] > maior) maior = v[i]; a variável maior deve receber o valor de v índice i verificar se v índice i é maior que a variável maior então atribuir v índice i à variável maior determinar um valor para maior # 7. int v[5] = {4, 3, 8, 2, 1}; declarar v como um vetor de inteiros declarar uma variável vetor de inteiros, v e inicializar com os valores 4, 3, 8, 2, 1 atribuir um vetor # 8. int maior = 0; declarar uma variável declarar a variável inteira maior e a inicializá-la com 0 apagar uma variável inteira # 9. ch = 0; atribuir 0 atribuir 0 à variável ch remover a variável ch # 10. while (ch != A) ch = getchar(); enquanto ch diferente de A enquanto ch diferente de A fazer com que ch receba um caracter do teclado remover um caracter do buffer de teclado # 11. getchar() ler obter um caracter do teclado apagar o teclado # 12. i += 2; acumular i acumular 2 ao valor de i atribuindo o resultado a i retirar 2 do valor de i # 13. while (i <= 10)
95
executar o laço enquando i menor que 10 executar o laço enquando i menor ou igual a 10 testar a condição do comando # 14. break sair interromper o bloco iniciar o bloco de comandos # 15. default executar executar este bloco padrão ignorar o bloco de comandos # 16. scanf ("%d", &n); obter o valor de n através do teclado obter o valor de n através de ponteiros e utilizando a máscara %d eliminar a variável n # 17. for (int i = 0; i < 3; i++) { auxiliar[j] = vetor[i]; j--; } para i de 0 enquanto i menor que 3 para i de 0 enquanto i menor que 3 fazer com que auxiliar receba vetor e depois incremente i e decremente j declarar o vetor auxiliar # 18. int auxiliar[3]; criar um vetor criar uma variável vetor de inteiros auxiliar de tamanho 3 apagar um vetor # 19. int *pont_vetor; declarar um inteiro declarar a variável ponteiro para inteiros pont_vetor copiar uma variável inteira # 20. while (*pont_vetor != 0) { pont_vetor++; } enquanto o conteúdo do ponteiro pont_vetor for diferente de 0 enquanto o conteúdo do ponteiro pont_vetor for diferente de 0 incrementar o endereço do ponteiro desalocar o endereço de pont_vetor # 21. pont_vetor++; incrementar pont_vetor incrementar o endereço do ponteiro pont_vetor alocar um endereço # 22. return (0); retornar retornar 0 interromper o programa # 23. if (v[j] < v[menor]) menor = j; atribuir o valor de j a menor quando v menor que v índice menor então menor deverá receber j declarar uma variável de ponto flutuante # 24. printf("%f, ", v[i]); imprimir o vetor imprimir o valor do elemento do vetor v com índice i, utilizando uma máscara %f inicializar o vetor v # 25. void declarar uma função declarar uma função que retorna nada encerrar a função # Fim do arquivo