Starting with MapleTA version 9.5, a new assignment type named Adaptive Assignment is available. Within this type of quiz questions can placed into one to five different groups or branches. Each branch can be treated as a different level of difficulty. A student's pathway through the various branches of questions is determined by the branching policy selected from among the options provided by MapleTA or from an instructor's short Maple script. Adaptive assignments do not include the usual Question Menu allowing students to select the order of the quiz questions.
MapleTA verion 9.5 Instructor documentaion:
http://www.maplesoft.com/support/help/MapleTA95/MapleTAInstructor/
Chapter 3.5 is about the Adaptive Assignment Editor:
http://www.maplesoft.com/support/help/MapleTA95/MapleTAInstructor/ch03s05.aspx
Note 1: Figure 3.14 in chapter 3.5 is correct. The text description just above the figure is not correct [1] as the text for decreasing difficulty uses correct answers instead of incorrect answers.
Note 2: A description of the Algorithmic settings of the Adaptive Assignment is missing [1] from the mapleTA Instructor help documentation. The following sections make use of the MapleTA 9.5 program to describe how the Adaptive Assignment Algorithmic settings work.
The Adaptive Assignment editor and settings start with the same editor look and settings options as the other available MapleTA assignment types. What is different is the addition of branches in the Select Questions step.
In the other assignment types, questions and their point values are selected for the asssignment and students are offered each question the instructor selects when the assignment is delivered to the student.
With the Adaptive assignment type, instructors select and place questions into branches (i.e. groups) and then select options on how a student can move from one branch of questions to another branch depending on how well the student has done so far in the assignment.
Selecting questions to add to branches works like selecting questions for any assignment. One difference is that question point values cannot be changed. Instead, a branch weight factor can be adjusted. All the questions in any branch have to be weighted as 1 point, but a whole branch can be weighted differently from other branches.
Four additional branches can be added to the default starting branch. And, the instructor can select a different starting branch.
There are two main types of settings that control Adaptive assignments. One type is the Grade or exit policy, the other type is the Branching policy.
The Grade policy setting determines when an assignment should end and how the assignment grade should be calculated. There are two forms of this policy, the Basic form and the Algorithmic form.
X questions seen
Y questions correct
Z questions incorrect
And, the Basic marking policy is the default one of
the assignment grade being the weighted sum of the branches visited i.e.
\[\sum_{ith\ visited\ branch} numberCorrectInBranch_i * weightOfBranch_i \]
These settings are located within the Adaptive assignment editor,
on the Select Questions page, within the Policies subpage.
All an instructor has to do to use the Basic Grade policy is to
pick the desired conditions (see above) in the "Grade Assignment When" box
and select the Basic option in the "Grade Policy" box.
Further testing of the Adaptive assignment might confirm that the Basic and Algorithmic forms of the Grade policy are not exclusive, but are combined to determine the earliest exit from the assignment. If an instructor wishes the Algorithmic form to prevail, then the stopping condition numbers used in the Basic form will have to be set sufficiently high to ensure this outcome. But, two tests (examples 2 and 3 below) show contradictory results [1]. Both examples 2 and 3 have a maximum limit of 5 questions and both example scripts have algorithmic exit conditions, yet only example 2 ends after 5 questions. Example 3 continues until the script exit condition is triggered.
It should be mentioned that it is even possible to use either of the above Maple script statements GRADE or returnGrade(N) when selecting the Basic marking policy, if the instructor selects the Algorithmic Adaptive branching policy settings described in the next section, since, as we'll see, the Algorithmic branching setting uses the same Maple programming script as the Algorithmic form of the Grade policy settings. However, under these circumstances, while the GRADE statement behaves as described above, returnGrade(N) becomes in effect the simpler GRADE statement, ending the assignment but using the default marking policy above, and not giving the student a mark of N. Thus, to use returnGrade(N), Algorithmic grading must be selected.
The Branching policy setting determines, after a question has been answered, from which branch the next question will be selected. Again, there are two forms of this policy, the Basic form and the Algorithmic form.
| Basic Settings | Algorithmic settings -------------------------------------------------------------------------------- Grading & exit | Exit assignment when | Exit when last executed policy | (select 1 or more) | script stmt is | X questions seen, or | GRADE; or | Y questions correct, or | returnGrade(N); | Z questions wrong | | | | final grade = SUM over | | ith_visitied_branch of | | ( num_correct_in_branch(i) | | * weight_of_branch(i) ) | -------------------------------------------------------------------------------- Branching | * increase branch by 1 | Last executed script stmt policy | for N (non-)consecutive correct | is a number or var value | * decrease branch by 1 | of branch to next question | for M (non-)consecutive incorrect|
Instructors can create and use their own script variables, but the values of the variables are not saved between questions; they are treated as local variables as in a function or procedure. Instructors have to rely on the state variables supplied by MapleTA (listed below) to know something of the past performance of a student during the assignment.
State variables provided in the Agorithmic branching form should also be treated as local varaibles, not as global variables that can be changed in the Maple script code and remembered in the next invocation of the script. For example, changing the variable streak to 0 will reset it only while the script is running.
Maple script code can include Maple variables and constants, as well as if, for and assignment statements. Examples below show all these statements. The return statement does not work.
As mentioned above, there is no warning or error message when improper Maple syntax is used. Be mindful of using := for assignment statements, especially since the the small script font size makes it easy to use a semi-colon by mistake.
To allow an instructor to adapt the delivery and marking scheme to a student's performance in the assignment, certain information of the past and current state of the assignment is needed. MapleTA makes the following variables available to the instructor to provide that state information.
num_branches: number of branches in the assignment
GRADE: statement triggers end of assignment and student receives a mark based on the default marking policy
returnGrade(X): statement triggers end of assignment and student receives a mark of X
branch_names: names of the branches as a list of strings
branch_weights: weights of the branches as a list of double values
start_branch: starting branch of the assignment
seen: number of questions a student has seen (i.e. done; value is never 0 in script)
correct: number of questions a student has correct
incorrect: number of questions a student has incorrect
streak: number of question correct/incorrect in a row
(+2 means 2 correct in a row, -3 means 3 incorrect in a row, value is never 0 in script)
responses: list of the students correct (1) or incorrect (0) responses
(a Maple list e.g [1, 0 , 1, 1, 1])
response_branches: list of the branches that each question was drawn from
current_branch: branch the last question was drawn from (1..num_branches)
#: Maple code comment-to-end-of-line character
Example 1: Algorithmic exit with default grading and Basic branching.
Grade the assignment after correctly answering three questions in a row in this 1 branch example.
Normally the streak variable would be used here in the script, but it doesn't always work [1]. See the failed examples in a later section of this page.
# Should be able to use simple if-stmt with streak variable:
# if streak = 3 then
# GRADE;
# end if;
# but have to use, for-loop instead of streak
#
# grade after 3 correct in-a-row
branch1_right := 0;
for i from 1 to seen do
if responses[i] = 1 then
branch1_right := branch1_right + 1;
elif responses[i] = 0 then
branch1_right := 0;
end if;
end do;
if branch1_right = 3 then
GRADE;
end if;
Example 2: Algorithmic exit and grading and Basic branching.
Grade the assignment after failing three questions at any time on the first branch or two questions at any time on the second branch.
Interestingly, this assignment has a maximum limit of 5 questions and it ends after 5 questions. Contrast this with example 3, which also has a maximum of 5 questions but does not exit after 5 questions [1]. Both example scripts have exit conditions.
# grade after 3 incorrect on branch 1
# or 2 incorrect on branch 2
branch1_wrong := 0;
branch2_wrong := 0;
for i from 1 to seen do
if responses[i] = 0 and response_branches[i] = 1 then
branch1_wrong := branch1_wrong + 1;
elif responses[i] = 0 and response_branches[i] = 2 then
branch2_wrong := branch2_wrong + 1;
end if;
end do;
if (branch1_wrong = 3) or (branch2_wrong = 2) then
returnGrade(-4.3); # return any grade for testing this script
end if;
Example 3: Algorithmic exit with default grading and Algorithmic branching.
Two topics are tested in this assignment, one at branch level 2 and the other at branch level 4. The assignment ends when both tests are passed perfectly with 5 right answers in a row. If any test question is incorrect a lower tutorial branch of questions is delivered, using branch 1 for the tutorial questions of the branch 2 test and using branch 3 for the tutorial questions of the branch 4 test. The student will have to be successful with 4 tutorial questions in a row to try any test questions again.
See the comment in example 2 about the maximum number of questions in this assignment being ignored.
# branch1 holds tutorial questions for test 1 questions in branch2
# branch3 holds tutorial questions for test 2 questions in branch4
leave := false; # set to true when assignment should exit
if current_branch = 1 then
if streak = 4 then # 4 in-a-row ok so go on to test in branch 2
next_branch := 2;
else
next_branch := 1; # else continue with tutorial Qs
end if;
elif current_branch = 2 then # go on to 2nd test if 5 in-a-row ok on this test
if streak >= 5 and response_branches[1+seen-5] = 2 then # check streak only on branch 2, not branch 1 and 2
next_branch := 4;
elif responses[seen] = 0 then # fallback to tutorial Qs if get a test Q wrong
next_branch := 1;
else
next_branch := 2;
end if;
elif current_branch = 3 then
if streak = 4 then # 4 in-a-row ok so go to test in branch 4
next_branch := 4;
else
next_branch := 3; # else continue with tutorial Qs
end if;
elif current_branch = 4 then # 5 in-a-row ok on test 2 means exit
if streak >= 5 and response_branches[1+seen-5] = 4 then
leave := true;
elif responses[seen] = 0 then # fallback to tutorial Qs if get a test Q wrong
next_branch := 3;
else
next_branch := 4;
end if;
end if;
if leave then
GRADE;
else
next_branch;
end if;
Example 4: Basic exit with default grading and Algorithmic branching.
The first question asks the student if they wish to start (or continue) with easier or harder questions and sends the student to the desired branch of questions. If they perform poorly with the harder branch (indicated by 3 failed questions in a row) or very well (say 10 in a row correct but the script test used 4 in a row correct) in the easier branch they are asked again which difficulty level they wish to continue with.
Students can stop and grade the assignment any time they wish.
next_branch := current_branch;
if current_branch = 1 then
if responses[seen] = 1 then # student wants to start with easier questions
next_branch := 2; # go to easier branch
else
next_branch := 3; # go to harder branch
end if;
elif current_branch = 2 then
# check for correct streak of 10 in branch 2
if streak >= 4 and response_branches[1+seen-10] = 2 then
next_branch := 1; # go to decision branch 1
else
next_branch := 2; # remain on this branch 2
end if;
elif current_branch = 3 then
# check for incorrect streak of 3 in branch 3
if streak <= -3 and response_branches[1+seen-3] = 3 then
next_branch := 1; # go to decision branch 1
else
next_branch := 3; # remain on this branch 3
end if;
end if;
next_branch;
Example F1: Algorithmic exit with default grading and Algorithmic branching.
This script should end the assignment when two questions are answered incorrectly in a row (there are two branches in this setup). But, this assignment ends when it reaches its 10 question limit, even when every question is answered incorrectly.
if streak = -2 then # this script also fails with condition streak = 2
GRADE;
end if;
In contrast, this script using the streak variable, works as expected, bouncing back and forth between branches 1 and 5 with streaks of 2 correct questions and 2 incorrect questions:
next_branch := current_branch;
if streak = 2 then
next_branch := 5;
elif streak = -2 then
next_branch := 1;
end if;
next_branch;
[1] Points in the text of this page marked with [1] are questions to settle or areas that need addressing.
Paul Kates
Mathematics Faculty CTE Liaison
pkates@uwaterloo.ca, x37047
Last modification date: Thu Jun 19 00:54:25 2014.