Work with adaptive assignment policies

An adaptive assignment is a specialized type of Möbius assignment that moderates a student's progression through an assignment using question branching.

While creating an adaptive assignment, specific adaptive assignment policies exist that control certain aspects of a student's attempt at the adaptive assignment:

Exit strategy — Determines when the student's attempt is considered complete and ready to be submitted for grading; the student is then exited from the assignment.
Grade policy — Determines how the final grade of the student's attempt is calculated.
Adaptive policy — Determines how the student is navigated between the branches of the assignment during their attempt.

Default settings exist for these adaptive assignment policies, but you can modify them as needed to suit your class's needs:

Standard options — Templates that accept custom values to define the adaptive assignment policies.
Algorithmic options — A custom Maple syntax-based algorithm is defined (that can be used in addition to or instead of the standard options) to fully customize the adaptive assignment policies.

Each time the student submits a response (and the response is graded), Möbius uses the adaptive assignment policies to determine whether (and from which branch) to reveal another question to the student or consider the student's attempt as complete and force them to exit the assignment with a specific grade.

The student's level of knowledge about a concept can then be determined (Example — beginner, intermediate, or advanced) based on how they progress through the assignment and the grade that they achieve.

Access adaptive assignment policies

To access the adaptive assignment policies for your adaptive assignment:

Click Policies when the 2. Select Questions tab is being viewed to access the adaptive assignment policies.

The adaptive assignment policies are displayed.

Standard options

The standard options of adaptive assignment policies use customizable templates you can modify to determine whether (and from which branch) to reveal another question to the student or consider their attempt as complete and exit them from the assignment.

Through the settings shown in this section, you can use the standard options to achieve the following example design of an adaptive assignment:

When a question is answered correctly, the student is navigated to a branch of increased difficulty (if a student continues to answer questions correctly, they remain on the branch of highest difficulty until they've seen the defined maximum number of questions).
When a question is answered incorrectly, the student is navigated to a branch of decreased difficulty (if a student continues to answer questions incorrectly, they remain on the branch of lowest difficulty until they've seen the defined maximum number of questions).
The student is exited from their attempt once 15 questions have been seen.
The student's grade is calculated based on the number of correct responses (worth 1 point) multiplied by the weight of the questions in the branch to represent the student's level of knowledge.

To use the standard options to define your adaptive assignment policies:

Select the check box of the standard exit strategy that you want to apply from the Grade Assignment When row.
- Questions Seen — The student's attempt is considered complete when they've seen the defined number of questions, regardless of the correctness of their responses (selected by default).
- Correct Responses — The student's attempt is considered complete once they've answered the defined number of questions correctly.
- Incorrect Responses — The student's attempt is considered complete once they've answered the defined number of questions incorrectly.

Define an integer value for the selected exit strategy check box(es).

Select the standard grade policy that you want to use:
- Basic grade policy (selected by default) — Each correct response is worth 1 and multiplied by the defined branch weight to calculate the student's grade.
- ELO grade policy — Based on the same rating system used to rank chess players. Responses are graded between 0 and 1, where 0 indicates no correct responses and 1 indicates all correct responses. Otherwise, the grade is calculated based on branch weight and difficulty.

Select the basic adaptive policy (selected by default).

Use the basic adaptive policy drop-down lists to define when to navigate the student to a more difficult or less difficult branch:
- Select to increase the branch difficulty when the student enters n consecutive or n non-consecutive correct responses.
- Select to decrease the branch difficulty when the student enters n consecutive or n non-consecutive incorrect responses.

Algorithmic options

The algorithmic options of adaptive assignment policies enable you to define your own algorithm — in Maple syntax — for fully customizable control over the adaptive policy, exit strategy, and grade policy beyond what the built-in standard options provide.

Define an adaptive assignment algorithm

Algorithmic options are defined within the algorithmic text field, which is revealed when either the algorithmic grade policy or algorithmic adaptive policy is selected.

Each time the student submits a response (and the response is graded), Möbius executes your defined algorithm to determine whether (and from which branch) to reveal another question to the student or consider their attempt as complete and exit them from the assignment.

Each time your algorithm is executed, it should produce one of these outputs:

A positive integer representing the branch number to draw from for the next question (check out the Example: Algorithmic grade policy with algorithmic adaptive policy section, below, to see how you can optionally append a non-negative real number representing a grade); or
A signal for the assignment to exit, either by:
- Referencing the reserved word GRADE, in which case the student's grade is calculated using the selected standard grade policy (basic or ELO); or
- Calling the procedure returnGrade(N), where N (a non-negative real number) is a grade that you define for the student to receive.

Adaptive assignment algorithmic variables

State variables — Variables that carry information about the assignment's branches and current status of the student's progress (and performance) through the assignment.

The following state variables are populated before each execution of your algorithm:

num_branches — The number of branches within the assignment.
branch_names — The names of the branches as a list of strings.
branch_weights — The weights of the branches as a list of doubles.
start_branch — The starting branch of the assignment.
seen — The number of questions the student has seen.
correct — The number of questions the student has answered correctly.
incorrect — The number of questions the student has answered incorrectly.
streak — The number of consecutive correct or incorrect responses.
grades — The list of the student's actual grades (0-1).
responses — The list of the student's correct (1) or incorrect (0) responses.
response_branches — The list of the branches that each question was drawn from.
current_branch — The branch that the most recent question was drawn from.

In addition to the available state variables, you can also define any local variables as needed when defining your algorithm (check out the Example: Algorithmic grade policy with algorithmic adaptive policy section, below, to see the usage of local variables).

Example: Algorithmic grade policy with algorithmic adaptive policy

Algorithmic options are recommended over standard options for finer control of the student's experience during their attempt and coverage of more possible scenarios that the student may encounter. Through the settings shown in this section, you can use the algorithmic options to achieve the following example design of an adaptive assignment:

When two consecutive questions on the current branch are answered correctly, the student is navigated to a branch of increased difficulty.
When two consecutive questions on the current branch are answered incorrectly, the student is navigated to a branch of decreased difficulty.
The student is exited from their attempt once 12 questions have been seen or if the student would be navigated beyond the available branch (Example — if the student is already on the branch of highest difficulty and has submitted two consecutive correct answers on this branch, the student is exited early. There's no branch available beyond the current branch that they're on, and there's no pedagogical need for the student to answer all 12 questions if they're already excelling on the branch of highest difficulty).
The student's grade is calculated as a score based on the highest branch that they achieved during their attempt, to more accurately classify the student's level of knowledge.

Consider an adaptive assignment with three branches and the following adaptive assignment policies:

An algorithmic grade policy is applied.
An algorithmic adaptive policy is applied.

An algorithm is then defined such that:

When a student answers two consecutive questions correctly on the same branch, the student is then navigated to the next branch of increased difficulty.
When a student answers two consecutive questions incorrectly on the same branch, the student is then navigated to the previous branch of decreased difficulty.
A maximum of 12 questions are to be viewed.

The following Maple syntax algorithmic code is used in the algorithmic text field:

nextBranch := current_branch: if abs(streak) >= 2 and response_branches[seen-2+1] = current_branch then nextBranch := current_branch + signum(streak): end if: # For this example we'll score student with highest branch completed score := max(0, nextBranch - 1): if nextBranch < 1 or nextBranch > num_branches or seen >= 12 then returnGrade(score); else nextBranch, score; end if;

Line 1-4 and 9-10 — Adaptive policy.
Lines 6-7 — Grade policy.
Lines 11-12 — Exit strategy.

While GRADE and returnGrade(n) do generate the exit signal (a string of a certain pattern) that Möbius looks for in the output, they don't themselves trigger a return. The example demonstrates one way to ensure it gets output, by having any occurrence of GRADE or returnGrade(N) be the last statement in the execution path that hits it. The example shows just a single returnGrade(N), but there can be many.

Alternatively, you could store would-be output in a local variable and have the variable itself be the last statement executed:

myOutput := current_branch:
if nextBranch < 1 or nextBranch > num_branches or seen >= 12 then
myOutput := returnGrade(score):
else
myOutput := nextBranch, score:
end if:
myOutput;

Another method involves wrapping your logic in a procedure and calling it. You'd use Maple's return command to force an immediate return:

proc()
...
if nextBranch < 1 or nextBranch > num_branches or seen >= 12 then
return returnGrade(score);
end if;
nextBranch, score;
end proc();