“c” baseado na aprendizagem por auto

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ósGraduaçã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
O48a
Oliveira, Cláudio Luís Vieira
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
estrelas;
lavradores
semearam
colheram.“
Arthur Charles Clarke
(1917-)
e,
nos
vez
campos
por
de
outra,
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 autoexplicaçã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: autoexplicaçã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 (autoexplicaçã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.
Aluno
Ambiente de
aprendizado
Modelo do
tutor
Modelo do
domínio
Modelo do
estudante
Figura 1: Modelo tradicional de um Sistema Tutor Inteligente
(FREEDMAN et al, 2000)
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.
Escolha do
modelo
do aluno
Escolha da
estratégia
de ensino
Figura 2: Escolha das táticas de ensino
(Konzen; Frozza, 1999)
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 todoparte.
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 Ndimensional 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
Aluno
Interface
aluno-engenho
Engenho de
inferência
Domínio
Conhecimento do
aluno
Interface do
professor
Professor
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.
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 SECoach (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 (WIEMERHASTINGS 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.
Análise
Léxica
Análise
Sintática
Análise
Semântica
Latente
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
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.
Mapeador
Acessar
Explicação
Corpus
Resolver
Gerar
Possuir
Aluno
Peso-Explicação
Etiqueta
Exemplo
Possuir
Possuir
Progresso
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 entidaderelacionamento 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).
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ódigofonte. 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
id#
If
id#
else
Sintaxe Terminador
NúmeroComponente
Deslocamento
Lexema
<e>caso;
verificar;
)
2
0
testar; se;
quando;</e>
<e>senão;
caso;
contrário;
id#
N
1
0
outra; forma;
outra;
maneira;</e>
Tabela 1: Armazenamento da estrutura “if-else” na relação Mapeador
id#
(expr#)
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úmeroExemplo
6
6
6
NúmeroSeleção- SeleçãoComponente Importância
Explicação
Início
Término
1
94
95
if
4
1
98
109
v[i] > maior
4
1
121
132
maior = v[i]
2
Tabela 2: Inclusão na relação Peso-Explicação
Peso
0,4
0,4
0,2
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
verificar
se
v
índice
i
e
maior
Radical
{verific}
{se}
{v}
{índic}
{i}
{é}
{maior}
Lexema
Radical
Lexema
que
{que}
índice
a
{a}
i
variável
{variável}
a
maior
{maior}
variável
então
{entã}
maior
atribuir
{atribu}
v
{v}
Tabela 3: Extração dos radicais
Radical
{índic}
{i}
{à}
{variável}
{maior}
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
verificar
se
v
índice
i
é
maior
que
a
variável
Etiqueta
Lexema
Etiqueta
{verific}
maior
{maior: VAR, v}
{se}
então
{entã}
{v: VAR, v}
atribuir
{atribu}
{índic}
v
{v: VAR, v}
{i: VAR, v}
índice
{índic}
{é}
i
{i: VAR, v}
{maior: VAR, v}
a
{à}
{que}
variável
{variável}
{a}
maior
{maior: VAR, v}
{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ências
verificar
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
verificar
se
v
índice
I
é
maior
que
a
variável
Etiqueta
Lexema
Etiqueta
{verific: VTD, v}
maior
{maior: VAR, v}
{se: PPOA, f}
então
{entã: ADV, d}
{v: VAR, v}
atribuir
{atribu: VBI+PPOA, v}
{índic: N, f}
v
{v: VAR, v}
{i: VAR, v}
índice
{índic: N, f}
{é: VLIG, f}
I
{i: VAR, v}
{maior: VAR, v}
à
{à: PREP+ART, f}
{que: PR, f}
variável
{variável: ?, f}
{a: PREP, d}
maior
{maior: VAR, v}
{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
Peso: 0,4
Observado: sim
if
Peso: 0,4
Observado: sim
v[i] > maior
Peso: 0,2
Observado: sim
maior = v[i]
avaliação
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
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
Código-Aluno
Número-Tópico
Número-Exemplo
NúmeroExplicação
Tentativa
Bloco-Código
Explicação
Avaliação (do STI)
Situação
(Classificação)
Data-Início
Data-Término
Valor
011
15
6
1
2
if (v[i] > maior)
maior = v[i];
verificar se v índice i é maior que a variável maior então atribuir v índice i à
variável maior
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.
C
1/9/2005 20:10:34
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 DataTé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
Nível
1
2
3
Respostas Obtidas
Errada
Correta Incompleta
Errada
Total
625
1
7
617
Média
100,00%
0,16%
1,12%
98,72%
Total
625
17
91
517
Média
100,00%
2,72%
14,56%
82,72%
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.
BlocoExplicação
Código
getchar() dividir precisão
dados enquanto
subtrair ponteiro
dividir multiplicar
digitar executar
curto sem atribuir
Avaliação (do STI)
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
Nível
1
2
3
Respostas Obtidas
Errada
Correta Incompleta
Errada
Total
625
4
621
Média 100,00%
0,00%
0,64%
99,36%
Total
625
68
557
Média 100,00%
0,00%
10,88%
89,12%
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
resultados,
STI
proposto
quanto
apresentou
analisados
de
um
uma
desempenho
maneira
global,
satisfatório.
Os
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,444444
10 while (ch != ‘A’)
ch != ‘A’
Essencial
0,444444
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
while
Essencial
4 while(i<y)
i
<
y
Essencial
{ i++;
i ++
Essencial
r*=x;
}
r *= x
Necessária
if
Essencial
6 if (v[i] > maior)
v[i] > maior
Essencial
maior = v[i];
maior = v[i]
Necessária
11 getchar()
getchar
Essencial
14 break
break
Essencial
15 default
default
Essencial
for
Essencial
17 for (int i = 0; i < 3; i++)
int i = 0
Desejada
{ auxiliar[j] = vetor[i];
i<3
Essencial
j--;
i
++
Essencial
}
auxiliar[j] = vetor[i] Essencial
j -Essencial
if
Essencial
23 if (v[j] < v[menor])
v[j] < v[menor]
Essencial
menor = j;
menor = j
Essencial
25 void
void
Essencial
Tabela 13: Algumas atividades propostas
Peso
0,285714
0,285714
0,285714
0,142857
0,4
0,4
0,2
1
1
1
0,190476
0,047619
0,190476
0,190476
0,190476
0,190476
0,333333
0,333333
0,333333
1
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).
BlocoExplicação
Código
getchar() dividir precisão
dados enquanto
subtrair ponteiro
dividir multiplicar
digitar executar
curto sem atribuir
Avaliação (do STI)
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.
BlocoExplicação
Código
getchar() apagar o teclado
Avaliação (do STI)
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’)
enquanto Entendimento aproximado da língua natural:
ch = getchar(); ch diferente enquanto {enquant: CONJSUB, d} ch {ch: VAR, v} diferente
de A
{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),
B
C
getchar()
Ler
break
Sair
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!
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!
Entendimento aproximado da língua natural:
sair {sair: VTI, v}
Índice de lexemas reconhecidos: 1.0
Mapeamento:
(break v),
D
pont_vetor++;
Classificador:
break 1.0 true
Avaliação: 1.0
Faixas: 0.0 - 1.0
Classificação: C - Correta
AutoExplC: Ótimo é isso mesmo.
incrementa Entendimento aproximado da língua natural:
r
incrementar {increment: ?, v} pont_vetor {pont_vetor: VAR,
pont_vetor 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
Peso: 0,44444
while
Peso: 0,44444
ch != ‘A’
Peso: 0,11111
ch = getchar
avaliação
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).
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
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
Avaliação (do STI)
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),
B
default
executar este
bloco padrão
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.
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
C int *pont_vetor;
Explicação
declarar a
variável ponteiro
para inteiros
pont_vetor
Avaliação (do STI)
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),
D
while (*pont_vetor != 0) enquanto o
{ pont_vetor++;
conteúdo do
}
ponteiro
pont_vetor for
diferente de 0
incrementar o
endereço do
ponteiro
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.
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
E pont_vetor++;
Explicação
incrementar o
endereço do
ponteiro
pont_vetor
Avaliação (do STI)
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),
F
printf("%f, ", v[i]);
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
imprimir o valor Entendimento aproximado da língua natural:
do elemento do imprimir {imprim: VTI+PPOA, v} o {o: ART, d}
vetor v com
valor {valor: N, f}
índice i, utilizando do {do: PREP+ART, f} elemento {element: N, f} do
uma máscara %f {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),
G
void
declarar uma
função que
retorna nada
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
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
Errada
Incompleta
Correta
Média Obtida
88,00%
52,00%
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.261269.
CHI, M. T. H.; BASSOK, M.; LEWIS, M. W.; REIMANN, P.; GLASER, R. Selfexplanations: 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 selfexplanations 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 selfexplanation. 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.130137, 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 CASEBASED 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
Numero
Tipo de Dados
Inteiro
Descrição
Caracter
Resolução
Memorando
Tamanho
Descrição
11
É a chave primária, recebe um número
inteiro automaticamente durante o
cadastro.
255
Descrição do problema formulado pelo
professor.
Código-fonte com a resolução do
problema.
Mapeador
Campo
Tipo
Tipo de Dados
Caracter
Comando
Caracter
Sintaxe
Terminador
Caracter
Caracter
Tamanho
Descrição
25
Tipo do componente: comando,
atribuição,
expressão,
operadores
lógicos
ou
aritméticos.
50
Primitiva da Linguagem “C” que
representa o comando.
255
Sintaxe esperada.
1
Caracter que representa o
terminador
do
comando,
normalmente
ponto-e-vírgula,
mas em alguns casos dois
pontos (case) ou nenhum (do).
2
Número de componentes que
formam a instrução.
2
Indica
a
partir
de
que
componente a instrução deve ser
composta.
Lexemas, da língua portuguesa,
que
permitem
mapear
a
respectiva
instrução,
apresentando-se
etiquetados
como essenciais ou opcionais.
Número-Componente Inteiro
Deslocamento
Inteiro
Lexema
Memorando
Explicação
Número-Exemplo
Tipo de
Dados
Inteiro
Número
Inteiro
Mensagem
Memorando
Seleção-Ínicio
Inteiro
11
Seleção-Término
Número-Tópico
Inteiro
Inteiro
11
11
Campo
Tamanho
Descrição
11
Número do exemplo ao qual a
explicação está relacionada.
Número
da
explicação
gerado
automaticamente durante o cadastro.
Texto formulado pelo professor, que
será apresentado para orientar o aluno
durante a explicação.
Posição de início, em termos de
caracter, do trecho do código-fonte.
Posição de término.
Número do tópico com o qual a
explicação se relaciona.
11
-
90
Peso-Explicação
Tipo de
Campo
Dados
Número-Exemplo
Inteiro
Número-Explicação Inteiro
Seleção-Início
Inteiro
Tamanho
Descrição
11
11
11
Número do exemplo relacionado.
Número da explicação relacionada.
Posição de início, em termos de
caracter, do componente dentro do
código-fonte.
Posição de término.
Componente da instrução.
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 do componente dentro do
contexto geral da explicação.
Seleção-Término
Componente
Importância
Inteiro
Caracter
Inteiro
11
255
1
Peso
Ponto
Flutuante
17,15
Corpus
Campo
Lexema
Etiqueta
Ocorrência
Tipo de Dados
Caracter
Caracter
Inteiro
Tamanho
Descrição
50
Contém o lexema.
50
Etiqueta atribuída ao lexema.
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.
Campo
Identificador
Descrição
Ignorar
Tipo de Dados
Caracter
Caracter
Caracter
Tamanho
Descrição
25
Conteúdo da etiqueta.
50
Descrição do conteúdo da etiqueta.
1
Determina se um lexema etiquetado com
este identificador deve, ou não, ser
considerando na determinação do
conteúdo da frase.
Etiqueta
Progresso
Campo
Código-Aluno
Número-Tópico
NúmeroExemplo
NúmeroExplicação
Tentativa
Tipo de Dados Tamanho
Descrição
Caracter
10
Código do aluno.
Inteiro
11
Número do tópico.
Inteiro
11
Número do exemplo ao qual se refere a
atividade.
Inteiro
11
Número da atividade.
Bloco-Código
Memorando
-
Explicação
Avaliação
Situação
Memorando
Memorando
Caracter
1
Data-Início
Data-Hora
-
Data-Término
Data-Hora
-
Inteiro
11
Quantidade de tentativas realizadas pelo
aluno nesta atividade.
Trecho do programa que deverá ser
explicado.
Explicação gerada pelo aluno.
Avaliação da explicação pelo STI.
Classificação gerada pelo STI, a partir
da avaliação. Pode ser: C- Correta, I –
Incompleta e E – Errada.
Data e horário em que o aluno iniciou a
resolução da atividade.
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
1 int y = 5;
int z = x + y;
2 printf("soma: %d", z);
3 if (x % 2)
4 while(i<y)
{ i++;
r*=x;
}
5 if (a > 5)
c = a + b;
else
c = a - b;
6 if (v[i] > maior)
maior = v[i];
7 int v[5] = { 4, 3, 8, 2, 1};
8 int maior = 0;
9 ch = 0;
Componente
int
y=5
int
z=x+y
printf
"soma: %d", z
if
x%2
while
i<y
i ++
r *= x
if
a>5
c=a+b
else
c=a-b
if
v[i] > maior
maior = v[i]
int
v[5] = 4 3 8 2 1
int
maior = 0
ch = 0
Importância
Essencial
Necessária
Essencial
Necessária
Necessária
Essencial
Necessária
Essencial
Essencial
Essencial
Essencial
Necessária
Essencial
Essencial
Necessária
Essencial
Necessária
Essencial
Essencial
Necessária
Essencial
Essencial
Essencial
Desejada
Essencial
Peso
0,333333
0,166667
0,333333
0,166667
0,333333
0,666667
0,333333
0,666667
0,285714
0,285714
0,285714
0,142857
0,25
0,25
0,125
0,25
0,125
0,4
0,4
0,2
0,5
0,5
0,8
0,2
1
92
Número Bloco de Código
10 while (ch != A)
ch = getchar();
11 getchar()
12 i += 2;
13 while (i <= 10)
14 Break
15 default
16 scanf ("%d", &n);
17 for (int i = 0; i < 3; i++)
{ auxiliar[j] = vetor[i];
j--;
}
18 Int auxiliar[3];
19 int *pont_vetor;
20 while (*pont_vetor != 0)
{ pont_vetor++;
}
21 pont_vetor++;
22 Return (0);
23 if (v[j] < v[menor])
menor = j;
24 printf("%f, ", v[i]);
25 Void
Componente
while
ch != A
ch = getchar
getchar
i += 2
while
i <= 10
Break
default
Scanf
"%d", &, n
for
int i = 0
i<3
i ++
auxiliar[j] = vetor[i]
j -int
auxiliar[3]
int
* pont_vetor
while
* pont_vetor != 0
pont_vetor ++
pont_vetor ++
return
0
if
v[j] < v[menor]
menor = j
printf
"%f, " v[i]
void
Importância
Essencial
Essencial
Desejada
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Desejada
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Essencial
Peso
0,444444
0,444444
0,111111
1
1
0,5
0,5
1
1
0,5
0,5
0,190476
0,047619
0,190476
0,190476
0,190476
0,190476
0,5
0,5
0,5
0,5
0,333333
0,333333
0,333333
1
0,5
0,5
0,333333
0,333333
0,333333
0,5
0,5
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