pyBKT: Bayesian Knowledge Tracing in Python

The pyBKT model requires a specific data structure to model student mastery. Mastery is treated as a latent variable with two states: "knowing" and "not knowing".

Required Variables

• num_subparts: Number of unique questions used for checking understanding.
• num_resources: Number of unique learning resources available.
• num_fit_initialization: Number of iterations in the EM step.

The Data Object Attributes

• data: A matrix of sequential checkpoints. Rows = subparts, Columns = student checkpoints.
  • 0: No response or no question asked.
  • 1: Wrong response.
  • 2: Correct response.
• starts: Defines each student's starting column index in the data matrix.
• lengths: Defines the number of checkpoints for each student.
• resources: Sequential IDs of resources at each checkpoint (matches the length of the data columns).
• stateseqs: The true knowledge state (leave undefined before running the model).

Model Output (fitmodel attributes)

• As: Transition probabilities between states (includes learns and forgets).
• learns: Probability of transitioning to "knowing" from "not knowing".
• forgets: Probability of transitioning to "not knowing" from "knowing".
• prior: Prior probability of "knowing".
• guesses: Probability of guessing correctly while "not knowing".
• slips: Probability of an incorrect response while "knowing".

Eigen Tensors support two layouts: ColMajor (the default) and RowMajor.

Important Constraints:

• Only ColMajor is currently fully supported; using RowMajor is not recommended.
• All operands in a tensor expression must use the same layout, otherwise a compilation error occurs.

To change the layout of a tensor, use the swap_layout() method. Note that swap_layout() reverses the order of the dimensions. To swap the layout while preserving the original dimension order, combine swap_layout() with a shuffle() operation.

// Explicitly specifying layouts
Tensor<float, 3, ColMajor> col_major;
TensorMap<Tensor<float, 3, RowMajor>> row_major(data, ...);

// Simple layout swap (reverses dimension order)
Tensor<float, 2, ColMajor> col_major_orig(2, 4);
Tensor<float, 2, RowMajor> row_major_swapped = col_major_orig.swap_layout();
// col_major_orig (2,4) becomes row_major_swapped (4,2)

// Swap layout while preserving dimension order
array<int, 2> shuffle(1, 0);
Tensor<float, 2, RowMajor> row_major_orig(2, 4);
Tensor<float, 2, ColMajor> col_major_preserved = row_major_orig.swap_layout().shuffle(shuffle);
// row_major_orig (2,4) becomes col_major_preserved (2,4)

The Roster class simulates a cohort of students. It tracks individual progress by storing only the current latent and observable states, making it highly efficient for simulating learning environments.

Key Operations:

• Roster(students=[...], skills=..., model=...): Initializes a roster for specific students and skills.
• update_state(skill, student, responses): Updates a student's state using a single response or an array of responses (e.g., np.ones(10) for 10 correct responses).
• get_state_type(skill, student): Returns the mastery state (e.g., StateType.MASTERED).
• get_mastery_prob(skill, student): Returns the probability of mastery.
• get_correct_probs(skill) / get_mastery_probs(skill): Returns aggregate statistics for the whole roster.
• add_student(skill, name): Adds a new student to a skill.
• remove_student(skill, name): Removes a student.
• reset_state(skill, student): Resets a student to their initial prior state.

from pyBKT.models import *
import numpy as np

model = Model()
model.fit(data_path='ct.csv')

# Initialize roster
roster = Roster(students=['Jeff', 'Bob'], skills='Calculate unit rate', model=model)

# Update state with 10 correct responses
roster.update_state('Calculate unit rate', 'Jeff', np.ones(10))

# Check mastery
if roster.get_state_type('Calculate unit rate', 'Jeff') == StateType.MASTERED:
    print("Jeff has mastered the skill!")

# Get aggregate probabilities
print(roster.get_correct_probs('Calculate unit rate'))

You can force the evaluation of a lazy expression using several methods:

1. Assignment to a Tensor: Assigning to Tensor, TensorFixedSize, or TensorMap triggers evaluation.
2. Using .eval(): Inserts an intermediate evaluation point in an expression tree. This is useful for improving performance in complex expressions or preventing aliasing issues (where the output tensor is also an input).
3. Using TensorRef: A wrapper that allows accessing individual elements of an expression by evaluating them on-the-fly. Use this for accessing subsets of values without materializing a full tensor.

When to use .eval():

• To prevent redundant computations in complex trees (e.g., before a reshape() or broadcast()).
• To avoid aliasing errors when the target of an assignment is also part of the expression (e.g., Y = Y / Y.sum()).

// 1. Evaluation via assignment
auto t3 = t1 + t2;
Tensor<float, 3> result = t3; // Evaluated here

// 2. Evaluation via .eval() to prevent aliasing
Y = Y / (Y.sum(depth_dim).eval().reshape(dims2d).broadcast(bcast));

// 3. Evaluation via TensorRef for on-the-fly access
TensorRef<Tensor<float, 3>> ref = ((t1 + t2) * 0.2f).exp();
float val = ref(0, 0, 0); // Evaluated on demand