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.

TIP: Check out Create an adaptive assignment for more details on creating an adaptive assignment.

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:

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

1. The adaptive assignment policies are displayed.

Standard options

NOTE: The standard options have default values defined for them. However, you can still customize these standard options as needed.

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.

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

1. 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.

TIP: You can select more than one standard exit strategy check box as your defined exit strategy. If more than one exit strategy is selected, whichever one is satisfied first is the exit strategy that's used to consider the student's attempt as complete.

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

NOTE: All exit strategy options have a default integer value of 10.

1. Select the standard grade policy that you want to use:

• When the basic grade policy is selected:

• Each correct response is worth 1 and multiplied by the defined branch weight to calculate the student's grade.
• Selected by default.

• When the ELO grade policy is selected:

• The ELO grade policy is 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.

NOTE: The basic grade policy and ELO grade policy can be combined with either the basic adaptive policy or the algorithmic adaptive policy.

1. Select the basic adaptive policy (selected by default).

NOTE: The basic adaptive policy can be combined with the basic grade policy or ELO grade policy.

1. 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.

NOTE:n is an integer between 1 and 5.

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 are selected.

NOTE: Selecting the algorithmic grade policy automatically selects the algorithmic adaptive policy.

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 of this help topic 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.

IMPORTANT: When working with the algorithmic options, you must define an algorithmic adaptive policy to control how the student is navigated between branches. You can then choose the type of grade policy that you want to combine with the algorithmic adaptive policy.

IMPORTANT: When the algorithmic grade policy is selected, your defined algorithm must use the returnGrade(N) (as opposed to the GRADE) since the algorithmic grade policy uses your algorithm to produce the grade.

NOTE: If an error occurs while executing your algorithm or it fails to return one of the expected outputs, Möbius will revert to the standard options to determine the student's next branch or exit strategy.

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 of this help topic to see the usage local variables).

NOTE:State variables and local variables are forgotten after each execution of your algorithm. State variables are regenerated in time for the next execution meaning that up-to-date data on the student’s progress is always provided.

Example: Algorithmic grade policy with algorithmic adaptive policy

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
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;

NOTE: This example uses the local variables of nextBranch and score.

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

IMPORTANT: Although the intent is to have a question now drawn from nextBranch, a grade is appended (in this example, using the local variable of score at line 10) in case factors external to the algorithm (Example — if the student clicks Submit Assignment) cause the assignment to end prematurely.

1
2
3
4
5
6
7
myOutput := current_branch:
if nextBranch < 1 or nextBranch > num_branches or seen >= 12 then
   myOutput := returnGrade(score):
else
   myOutput := nextBranch, score:
end if:
myOutput;

1
2
3
4
5
6
7
proc()
   ...
   if nextBranch < 1 or nextBranch > num_branches or seen >= 12 then
      return returnGrade(score);
   end if;
   nextBranch, score;
end proc();