Hello my name is Daniel Weitekamp
And I’ll be discussing my paper for CHI 2020:
An Interaction Design for Machine Teaching to Develop AI Tutors
It has probably been a very long time since many of you have been tutored in any academic setting
or thought very deeply about the process of tutoring,
but I would like to begin by convincing all of you that tutoring is really a remarkable thing.
In fact, tutoring has an immense effect on learning
and is estimated to improve learning outcomes by about two standard deviations over traditional instruction alone.
So what is it that makes tutoring so effective?
Well, there are quite a few interactions that a tutor and tutee engage in
that are beneficial beyond the sort interactions afforded by lectures and readings.
And for the most part these interactions are all quite challenging to provide
to students without considerable one-on-one instruction time.
However, it is possible to implement these interactions
in what are called Intelligent Tutoring Systems or ITSs;
educational technologies which mimic the support provided by human tutors.
Like human tutors ITSs
Break down problems into steps and give feedback along the way
Provide hints and elaborative feedback
And, model student’s learning to decide when they need more practice and when they should move on to new topics
As it turns out, in many domains, ITSs have improved learning outcomes beyond even what human tutors are capable of providing
an outstanding outcome with the potential to considerably improve the education systems of the world
albeit with one unfortunate caveat.
ITSs take a considerable amount of time and expertise to author
and as a result, have not been used very widely outside of classroom studies.
For example, to build a model-tracing ITS
a form of ITS which uses production rules to model the steps of a domain
a programmer would need to spend 200 to 300 hours programming
just to make a single hour of instructional material
Example-tracing tutors cut this time down to 50-100 hours of developer time
and require no specialized programming expertise other than some familiarity with excel formulas
Although scaling example tracing tutors to multiple problems can be time consuming.
Building ITSs is scalable in a way that human tutoring is not.
One ITS can teach millions of people one thing.
But tutoring a single human is considerably more efficient in terms of the time cost
of instilling knowledge in a single tutor, artificial or not.
If one tutored someone to the point of mastering a domain,
that tutee can in turn tutor a limited number of other people without much additional instruction,
meaning tutoring another tutor has a nearly 1 to 1 return,
this is 50 times faster at least than building an ITS.
In this talk I will describe our efforts to create an authoring tool
which builds widely deployable ITSs in a manner very similar to tutoring human learners.
We hope to allow ITS authors to teach a simulated learner,
like they would a human student, to encode the behavior of an Intelligent Tutoring System in an interactive process.
Simulated Learners are a form of AI that learn like humans do from examples and correctness feedback.
To build an ITS with a simulated learner,
an ITS author provides demonstrations of correct solutions to problems for the simulated learner to learn from,
then the user grades the simulated learner’s attempts at solving problems to refine it’s understanding of what it has learned.
Our goal is to make the process of making an ITS with a simulated learner
take about the same amount of time as tutoring a human
and require about the same amount of expertise as the average teacher or tutor.
In this talk I will discuss our new interaction design for training simulated learners by tutoring,
which supports more effective training of simulated learners than previous designs.
Additionally, I will discuss the results of our user study,
which compares CTAT example-tracing with our simulated learner based authoring system.
Finally I will discuss some qualitative results from this user study which will inform future work.
To begin, let's establish example-tracing based authoring as a baseline for comparison.
Example-tracing tutors are authored by demonstrating solution paths in a tutoring interface to construct a behavior graph of state nodes and action edges
that specify what steps are considered correct at every intermediate state of a problem.
The behavior graph for a single problem can then be edited so that each entry becomes a variable
as part of a template that can be used to mass produce problems in an excel spreadsheet.
Excel formulas are then used to determine the correct values of each step of a problem from its start state.
Overall, CTAT is a quick and easy method for specifying the behavior of single problems,
but requires a bit of time and expertise to extend to use for mass producing many problems.
One drawback of CTAT example-tracing is that for many kinds of problems,
several behavior graph templates must be generated to account for the different steps
which are present or absent in different problem instances.
For example, in a three-by-three multi-column addition problem one must either carry or not carry a one after adding along each column.
These two problems for example cannot be generated from the same behavior graph template,
and since there are three places to carry or not carry a one
there are 2^3 or 8 corresponding different behavior graph templates
which an author must build to support all three digit-by-three digit addition problems.
A human, of course, can easily learn the general pattern which is applied across each of the columns
in these examples without the need to learn a new mental model for each unique problem type.
Like humans, our simulated learners can learn general rules from examples and correctness feedback
provided by an ITS author.
These rules are similar to the rules a programmer would write to specify the behavior of a model-tracing tutor.
Thus simulated learner based ITS authoring tools can support most of the capabilities of a hand programmed tutoring systems
without the time and expertise requirements of programming.
The learning mechanisms employed by our simulated learners are not specific to any particular domain.
In past work, it has been shown that simulated learners can master tasks from a wide range of domains.
For example simulated learners built with the Apprentice Learner Framework, the same framework we use in this study,
have mastered several domains including:
Algebra and other math domains, Stoichiometry, English Grammar, Chinese to English Translation,
And even Video Games.
So how were these simulated learners in previous work trained to reach mastery in all of these domains
and what does mastery mean?
I’ll begin by describing how a simulated learner is trained.
The user begins by demonstrating how to correctly take steps in a problem
and in order to make these demonstrations more clear
the user indicates what information they used in the interface to take that step.
From these demonstrated actions, the agent induces skills that explain those demonstrations,
and on subsequent problems the agent tries to apply those skills
and the user is prompted to give positive feedback (say “yes”)
if the action the simulated learner took was correct,
and negative feedback (say “no”) if it was incorrect.
Now keep in mind that simulated learners do not just parrot back exactly what the user showed them.
As a simulated learner is tutored it induces skills and learns the conditions under which they should be applied
So it is often the case that for each step of a problem,
a simulated learner may believe that several of its skills are applicable for producing the next action given a problem state,
leading to multiple conflicting hypotheses for what to do next.
How a simulated learner decides which of these actions to take depends on it’s implementation.
But, the general idea is that for each action which the simulated learner produces that is wrong, the user will give negative feedback
until a correct action is produced.
At this point the correct action will be confirmed in the interface
and the simulated learner will try to produce an action for the next step of the problem.
A simulated learner reaches mastery when for every kind of problem in a target domain
it can produce a series of correct actions that lead from the start state of the problem to its end state.
As it turns out,
getting a simulated learner to mastery performance in a domain is not sufficient to produce an ITS for that domain.
One reason for this is that aiming for mastery requires the simulated learner to only learn one solution strategy for each type of problem,
and we may want to be able to support multiple solution strategies.
Another reason that mastery performance is too weak of a criteria for training a simulated learner to function as an ITS
is that although a simulated learner that has reached mastery performance knows what to do,
it doesn’t necessarily know what not to do.
When we take the skills that the simulated learner has learned and use them to run an ITS
those rules will mark as correct any of the actions which the simulated learner would have had in their conflict set,
some of which the author may not have had the opportunity to remove from consideration even though they produce incorrect actions.
A very disastrous example of this is when the simulated learner hasn’t quite nailed down when it should press the done button to conclude a problem.
If it thinks it can press the done button too early this would allow students working in the ITS to press the done button before they have finished a problem,
circumventing most of the required steps.
Thus, the criteria we should instead shoot for is model tracing completeness,
which means that the production rules that the simulated learner creates, produce all of the correct actions intended by the author and no incorrect actions.
No simulated learner prior to this work has been shown to exhibit model tracing completeness in any nontrivial way
when trained interactively.
In this work we show that it is possible to teach simulated learners to achieve model tracing completeness
by using our new interaction design which deviates slightly from typical tutoring interactions.
I’ll begin by showing a demo of our interaction design in use
and then circle back on some of the features which are new in this work and essential to its efficacy as an ITS authoring tool.
Training begins by setting the start state for a problem and then solving it step-by-step.
At each demonstration the user picks out the interface elements from which the inputted value was computed.
From this information, the simulated learner finds a formula which takes in the highlighted arguments
and outputs the demonstrated value.
These induced formulas are the beginnings of skills.
The simulated learner will learn the conditions for using these skills over the course of training.
When I add three vertically aligned numbers here for the second time
the simulated learner will associate this demonstration with the skill that it learned from the previous column,
and learn that this skill can be applied to any column.
The same is true for the skill which carries the ten digit across columns.
Now I will set up a new problem.
The simulated learner immediately knows what to do
and the first action in its conflict set is correct.
Note that we can see highlighted on the screen the two interface elements that the simulated learner has used to compute the value produced by
applying the add skill.
In previous interaction designs this information was not available to the user,
making the reasoning behind the simulated learner’s actions somewhat ambiguous.
Additionally, in previous interaction designs all we could do at this point was say yes here
And in fact if we do just that,
we find that the simulated learner will be correct on each step all the way to the end.
The simulated learner has reached mastery on this kind of problem but it hasn’t reached model tracing completeness.
If I set up this problem again we see that the simulated learner is aware that it can add at this step,
but suppose we would like to relax the order in which students must do each step
and allow for carrying the tens digit before placing the ones digit below.
A new feature of our interaction design is that we can always demonstrate different solution paths.
At this next step of the problem one of the next steps is taken too early
so we’ll queue negative feedback,
the other action is correct so we’ll queue positive feedback and submit.
To make a fully model tracing complete tutoring system in this domain
the author would go through many more problems along many more solution paths
until they are confident that the simulated learner produces the correct behavior
in a variety of problems and solution paths.
The fact that we show the user the full conflict set at each step
is important to the authoring process
as it helps them know in what situations the simulated learner’s production rules exhibit strictly the correct behavior.
To reiterate the features which are new in our interaction design, are:
A visualization of the elements used in each application of a skill.
The ability to see the simulated learner’s conflict set.
The ability to choose any action in the conflict set to apply or give feedback to.
And the ability to demonstrate alternative solution paths at any point
We conducted a user study where users attempted to build multi-column arithmetic tutoring systems by training simulated learners with our interaction design.
We also had users try to build the same tutoring system with CTAT example tracing for comparison.
We recruited 10 graduate students, 8 of which were familiar with the CTAT authoring tools.
In both the CTAT and simulated learner conditions,
users were limited to 45 minutes of authoring time.
In the course of this 45 minutes
users who authored with Apprentice Learner simulated learners
via our new interaction design
created nearly complete tutoring systems and achieved about four times better completeness
within 45 minutes than they did with CTAT example tracing.
Overwhelmingly, users reported that they enjoyed teaching the simulated learner
more than authoring with CTAT,
and several users reported that they found
seeing the steadily improving performance of the simulated learner satisfying.
Our four fold speedup in authoring time
means we could likely expect our authoring tool to have an effective efficiency of about 12 hours per hour of instruction.
However, we believe future work could yield an efficiency much closer to 1 to 1.
Some of the qualitative observations from our study revealed that further improvements could be made to our interaction design to improve usability.
Firstly despite our added functionality to help users achieve model tracing completeness they tended to naturally fall into a pattern of feedback
they tended to naturally fall into a pattern of feedback which only trained their agents to mastery performance.
Overall, users did not consistently give feedback to the whole conflict set until we reminded them that they should do so.
In future work we would like to try alternative interaction designs
to make the goal of model-tracing completeness more intuitive without need for intervention.
Additionally our interaction design did not provide much assistance to users
when they needed to to recover from training mistakes.
In future interaction designs we would like to include features that allow users to undo actions,
and recover from mistakes made early in the training process.
Another issue we observed was that users had trouble keeping track of which types of problems they had already trained completely and which they had not.
Moreover users had trouble knowing when they were done training their simulated learners.
In principle since the simulated learner has a complete memory of what it has seen,
we believe it could be possible for a simulated learner to be an active learner,
capable of proposing problems and solution paths
which would provide it with the greatest counter factual information gain.
All of these changes could be made in conjunction with improvements to our simulated learners’ underlying AI to make more accurate inferences from less user input.
To conclude, I would like to discuss the importance of this research in light of a number of potential use cases.
One may raise the question, “why do we need to make building ITSs faster and easier?
Couldn’t we simply build ITSs the hard way and just keep using them?”
In principle this is true,
but curriculums change, and teachers often have unique ways of teaching their material.
Thus, making ITS authoring easy
means they will be more likely to be used by teachers and instructional designers
to meet the particular needs of their classrooms.
With ITSs showing expected learning gains of two standard deviations or more,
implementing ITSs at scale has an immense potential.
And, being able to support a wide range of teacher, and district expectations
is an important step toward seeing wide ITS usage.
Secondly, ITS research is bottlenecked by the ability to build and deploy ITSs with different features
that can be tested against each other.
With faster and easier authoring tools,
the ITS research community can more readily determine
what tutoring system designs work best in which contexts.
Lastly, one of the goals of this research is to make it so that anyone can build an ITS.
This includes private and military actors
who need to quickly teach confidential information to their project teams to start making progress faster.
Thank you all for listening, and stay healthy!