UKTF: Unified Knowledge Tracing Framework for Subjective and Objective Assessments
^††thanks: Corresponding author: Chunyan Zeng, Email: cyzeng@hbut.edu.cn.

• •

  Answer Data Modeling: The learner’s answer data is organized into a time series, where each time point corresponds to an answer event. Each answer event comprises question information and the answer result. The learner’s answer data at time $t$, denoted as $x_{t}$, is set as a one-hot encoding of the learner’s interaction tuple $\{e_{t},r_{t}\}$, where $x_{t}\in\{0,1\}^{2N}$.

• •

  Knowledge State Modeling: The Long Short-Term Memory model (LSTM) is employed to model the temporal dependencies in learners’ answer sequences. A knowledge state variable $h_{t}$ is introduced to represent the learners’ mastery level of the knowledge concepts.

• •

  Parameter Learning and Optimization: Through supervised learning, the parameters of the model are learned. Using known answer data, the parameters are adjusted through the backpropagation algorithm and a gradient descent optimizer to minimize the difference between the predicted answer outcomes and the actual answer outcomes. The loss computation for the entire answer sequence of a single learner is as follows:

  $$L=\sum_{t}\ell(y^{T}\delta(e_{t+1}),r_{t+1})$$

  (1)

• •

  Answer Prediction: The knowledge state variable $h_{t}$ is passed through an output layer to map it to the probability of the student answering each question correctly, thereby enabling the prediction of answers.

• •

  Knowledge Encoding: The learner’s answer data is encoded into a form suitable for model processing, and firstly, one-hot encoding is applied to obtain the neural network’s input data $e_{t}$ and the combined value matrix components’ data $x_{t}=(e_{t},r_{t})$, where $q_{t}$ represents the question label at time $t$, and $r_{t}$ represents the learner’s response at $t$. Subsequently, an embedding layer is utilized to encode the data into continuous embedding vectors $m_{t}$ for $e_{t}$ and $s_{t}$ for the combination $(e_{t},r_{t})$.

• •

  Knowledge State Modeling: The DKVMN network is employed to model the changes in students’ knowledge states. Two memory matrices are introduced: a static key matrix and a dynamic value matrix. The key matrix represents knowledge concepts, while the value matrix represents the learners’ mastery levels of these concepts.

• •

  Model Training and Optimization: During the training process, the standard cross-entropy loss between the predicted answer probability $p_{t}$ and the true label $l_{t}$ is minimized using the gradient descent algorithm to jointly learn the embedding matrices and other parameters. The formula for the loss function is as follows:

  $$L=-\sum_{t}(l_{t}\mathrm{log}p_{t}+(1-l_{t})\log(1-p_{t}))$$

  (2)

• •

  Answer Prediction: By incorporating the vector $f_{t}$ that captures the learner’s comprehensive knowledge level and question characteristics, the probability $p_{t}$ of the learner correctly answering the question is obtained through a fully connected layer with a sigmoid activation function, thereby enabling prediction of the learner’s response. Specifically, it is defined as:

  $$p_{t}=\sigma\left(W_{f}\cdot f_{t}+b_{f}\right)$$

  (3)

• •

  Knowledge Graph Construction: The GKT model structures the course exercises into a graph $G=(V,E,A)$ potentially, decomposing the requirements for mastering course exercises into $N$ knowledge concepts, referred to as the node set $V=\{v_{1},\cdots,v_{N}\}$. These knowledge concepts share dependencies, denoted as edges $E\subseteq V\times V$, and the degree of dependency is represented by the adjacency matrix $A\in\mathbb{R}^{N\times N}$.

• •

  Knowledge State Modeling: The learner, at time step $t$, possesses an independent knowledge state $h^{t}=\{h_{i}^{t}\mid i\in V\}$ for each knowledge concept, where this knowledge state evolves over time. When the learner attempts an exercise $v_{i}$ related to knowledge concept $i$, not only does the learner’s knowledge state for concept $i$ update, but also the knowledge states $h_{j}^{t}$ of adjacent concepts $j\in N_{i}$ are updated, where $N_{i}$ denotes the set of nodes adjacent to node $v_{i}$. The updating process in the GKT model is accomplished through two steps: Aggregation and Update, performed by a Graph Convolutional Network (GCN).

• •

  Model Training and Optimization: During the training process, the model is trained by minimizing the Negative Log-Likelihood (NLL) loss in order to achieve the best model performance.

• •

  Answer Prediction: Based on the updated knowledge states, the prediction probability $p_{t}$ of the learner correctly answering each knowledge concept is obtained through a fully connected layer with a sigmoid activation function, enabling the prediction of the learner’s responses to questions.

DKT model predicts learners’ future performance in learning by analyzing their historical answer data, employing Long Short-Term Memory (LSTM) to capture the temporal changes in learners’ knowledge states [28]. The specific definitions are as follows:

Where $h_{t-1}$ represents the hidden state at the previous time step, $h_{t}$ denotes the current knowledge state of the learner, and $y_{t}$ represents the probability of the learner correctly answering at time $t$.

DKVMN model takes learners’ answer data as input and utilizes a dynamic key-value memory matrix to store learners’ knowledge states. The model employs two memory matrices: a static key matrix and a dynamic value matrix, which are used to store fixed knowledge point information and learners’ dynamically changing knowledge states, respectively. The DKVMN model utilizes an attention mechanism to control read and write operations, thereby enabling dynamic updates to the knowledge state. It is primarily composed of three components:

• •

  Acquire Relevant Weights: The query is performed by leveraging the embedding vector $m_{t}$ to interrogate the key storage matrix $M^{k}$. This involves computing the inner product between $m_{t}$ and each key slot $M^{k}_{(i)}$ within the matrix. Subsequently, a softmax activation function is applied to transform these inner products into a probability distribution, representing the weights $w_{t}\in\mathbb{R}^{N}$ that quantify the involvement of each knowledge point in the question at time $t$. The computation formula is as follows:

  $$w_{t}(i)=\mathrm{Softmax}(m_{t}^{T}M^{k}(i))$$

  (6)

• •

  Reading Process: The reading vector $r_{t}$ is computed based on the value matrix $M_{t}^{v}$ and the knowledge point relevance weights $w_{t}$. The vector $r_{t}$ represents the learner’s mastery level of the given exercise. The computation formula is as follows:

  $$r_{t}=\sum_{i=1}^{N}w_{t}(i)M_{t}^{v}(i)$$

  (7)

  Given that each exercise possesses its inherent difficulty, the reading vector $r_{t}$ and the embedding $m_{t}$ of the input exercise are concatenated vertically. This concatenated vector is then passed through a fully connected layer with a tanh activation function, yielding an aggregated feature vector $f_{t}$, which encapsulates both the learner’s mastery level and the prior difficulty of the exercise. Subsequently, $f_{t}$ is fed into another fully connected layer with a sigmoid activation function to predict the probability $p_{t}$ that the learner will correctly answer the question. The specific implementation process is outlined as follows:

  $$f_{t}=\tanh(W_{1}^{T}[r_{t},m_{t}]+b_{1})$$

  (8)

  $$p_{t}=\mathrm{sigmoid}(W_{2}^{T}f_{t}+b_{2})$$

  (9)

• •

  Writing Process: After the learner answers the question, the value memory matrix $M_{t}^{v}$ is updated based on the learner’s response. When incorporating the learner’s knowledge growth $s_{t}$ into the value matrix components, the existing memory is first erased before adding the new information.

  Given a write weight $w_{t}$ (which is the same as the knowledge point relevance weight $w_{t}$ utilized in the reading process), the computation of the erase vector $e_{t}$ is performed as follows:

  $$e_{t}=\mathrm{sigmoid}(E^{T}s_{t}+b_{e})$$

  (10)

  Where the transformation matrix $E\in\mathbb{R}^{d_{v}\times d_{v}}$ has a shape of $d_{v}\times d_{v}$, and $e_{t}\in\mathbb{R}^{d_{v}}$ is a column vector with $d_{v}$ elements, each element taking a value within the interval $(0,1)$. The memory vector of the value component $M_{t-1}^{v}(i)$ from the previous time step is modified as follows:

  $$\tilde{M}_{t}^{v}(i)=M_{t-1}^{v}(i)[\mathbf{1}-w_{t}(i)e_{t}]$$

  (11)

  Where $\mathbf{1}$ represents a row vector of all ones, and thus, only when both the weight at the corresponding matrix position and the erase element are 1, will the element at that matrix position be reset to 0. After erasing the memory, an add vector $a_{t}$ is employed to update the value matrix $M_{t}^{v}$, and the update of the value matrix at each time step is given by:

  $$M_{t}^{v}(i)=\tilde{M}_{t-1}^{v}(i)+w_{t}(i)a_{t}$$

  (12)

  Given the transformed memory information and the current problem features, a feature vector $f_{t}$ is constructed. Subsequently, this feature vector is fed into a fully connected layer with a sigmoid activation function to predict the probability $p_{t}$ that the learner will correctly answer the question. The specific implementation process is detailed as follows:

  $$p_{t}=\mathrm{sigmoid}(W_{2}^{T}f_{t}+b_{2})$$

  (13)

The GKT model [26] represents learners’ historical answer data as a graph structure, where each node signifies a knowledge concept, and the edges between nodes indicate the relationships between these knowledge concepts. By observing learners’ answer patterns, the model updates the states of the nodes within the graph, thereby dynamically tracking learners’ mastery levels of various knowledge concepts. This model primarily comprises two components:

• •

  Information Aggregation: We define an answer embedding matrix $E_{x}\in\mathbb{R}^{2N\times e}$ and a skill embedding matrix $E_{c}\in\mathbb{R}^{N\times e}$, where $E_{c}(k)$ represents the $k$-th row vector of matrix $E_{c}$, and $e$ is the embedding dimension. At time step $t$, for the answered knowledge concept $i$ and its neighboring knowledge concepts $j$, the hidden states and embeddings are aggregated according to the following specific formula:

  $$h_{k}^{\prime t}=\begin{cases}[h_{k}^{t},x^{t}E_{x}]&(k=i)\\ [h_{k}^{t},E_{c}(k)]&(k\neq i)\end{cases}$$

  (14)

• •

  Feature Update: Update the hidden state of each knowledge point through aggregated features and the structure of the knowledge graph. The specific steps are as follows:

  $$m_{k}^{t+1}=\begin{cases}f_{\text{self}}(h_{k}^{\prime t})&(k=i)\\ f_{\text{neighbor}}(h_{i}^{\prime t},h_{k}^{\prime t})&(k\neq i)\end{cases}$$

  (15)

  $$\widetilde{m}_{k}^{t+1}=G_{ea}(m_{k}^{t+1})$$

  (16)

  $$h_{k}^{t+1}=G_{gru}(\tilde{m}_{k}^{t+1},h_{k}^{t})$$

  (17)

  In this context, $f_{\text{self}}$ and $f_{\text{neighbor}}$ represent the self-function and neighbor-function respectively, where $f_{\text{self}}$ is implemented as a Multilayer Perceptron (MLP). $G_{\text{ea}}$ denotes an Erase-Add gate, which performs feature erasing and enhancement on the aggregated feature vector $m_{k}^{(t+1)}$ to better simulate the learner’s knowledge state characteristics. Additionally, $G_{\text{gru}}$ is a Gated Recurrent Unit (GRU) that is utilized to perform feature extraction, memory retention, and updating on $\tilde{m}_{k}^{(t+1)}$.

  $f_{neighbor}$ is an arbitrary function defined based on the structure of the knowledge graph to propagate information to adjacent nodes. Nakagawa et al. proposed two optional implementations: a statistical-based approach and a learning-based approach. In this study, a statistical-based dense graph approach is adopted, with the formula outlined as follows:

  $$f_{\mathrm{outgo}}(\mathrm{h^{\prime}}_{i}^{t},\mathrm{h^{\prime}}_{j}^{t})=\mathbf{A}_{i,j}f_{\mathrm{outgo}}([\mathrm{h^{\prime}}_{i}^{t},\mathrm{h^{\prime}}_{j}^{t}])$$

  (18)

  $$f_{\mathrm{income}}(\mathrm{h^{\prime}}_{i}^{t},\mathrm{h^{\prime}}_{j}^{t})=\mathbf{A}_{j,i}f_{\mathrm{income}}([\mathrm{h^{\prime}}_{i}^{t},\mathrm{h^{\prime}}_{j}^{t}])$$

  (19)

  $$f_{\mathrm{neighbor}}=f_{\mathrm{outgo}}(\mathrm{h^{\prime}}_{i}^{t},\mathrm{h^{\prime}}_{j}^{t})+f_{\mathrm{income}}(\mathrm{h^{\prime}}_{i}^{t},\mathrm{h^{\prime}}_{j}^{t})$$

  (20)

  The dense graph is computed as follows:

  $$\mathbf{A}_{i,j}=\begin{cases}\frac{n_{i,j}}{\Sigma_{k}n_{i,k}}&\quad\mathrm{i\neq j}\\ \\ 0&\quad\mathrm{i=j}\end{cases}$$

  (21)

  Based on the updated knowledge state, the prediction probability $p_{t}$ of the learner correctly answering each knowledge point at the next time step is obtained through a fully connected layer with a sigmoid activation function, thereby enabling prediction of the learner’s responses. The specific formula is as follows:

  $$p_{k}^{t}=\sigma(W_{\text{out}}h_{k}^{t+1}+b_{k})$$

  (22)

Since the scores of subjective test questions are multi-valued discretely distributed rather than simply right or wrong. Therefore, some of the structure of the DKT model needs to be adjusted to fit the new prediction task. The specific adjustments are as follows:

• •

  Question Encoding: For the response tuple $x_{t}=(e_{t},a_{t})$, after one-hot encoding, $x_{t}\in\{0,1\}^{2E}$, with a length twice the total number of exercise items. For subjective test questions, this experiment directly encodes the question ID and corresponding score into the feature vector. Specifically, if an exercise item is attempted, the corresponding position in the first half of $x_{t}$ is set to 1, otherwise 0; if an exercise item is attempted, the corresponding position in the second half of $x_{t}$ represents the specific score, otherwise 0. The detailed encoding formula is as follows:

  $$x_{t}(i)=\begin{cases}1&i=e_{t}\\ a_{t}&i=e_{t}+n_{question}\end{cases}$$

  (23)

• •

  Loss Function: For the subjective test questions, the knowledge-tracking task can be defined simply as a regression problem, so the loss function was adjusted from BCELoss to MSELoss.

• •

  Branch Network: The final output layer of the original DKT model usually uses a softmax activation function to predict how well the learner will answer the questions, right or wrong. For subjective test questions, a fully connected layer with a sigmoid function will be added to output the learners’ scores on the subjective test questions.

In response to the scoring characteristics of the subjective questions, some adjustments to the structures of the DKVMN model are as follows:

• •

  Question Encoding: For subjective test items, the problem IDs are encoded using one-hot encoding, and the response tuple $x_{t}=(e_{t},a_{t})$ is correlated with the number of knowledge points, where the specific encoding formula is given as follows:

  $$x_{t}=e_{i}+a_{i}*n_{question}$$

  (24)

• •

  Loss Function: The original DKVMN model picks binary cross-entropy with logits for model optimization. For the subjective test questions, the loss function was adjusted to MSELoss.

• •

  Branch Network: The final output of the original DKVMN model is the probability of answering the test question correctly, and for the subjective test questions, a fully connected layer with a sigmoid function is added to change the output to a normalized score for the test question.

The experiment adapted the GKT model by modifying the classification task to a regression task and applying the GKT model to the prediction of scores on subjective test questions.

• •

  Question Encoding: The encoding process fuses the knowledge point ID $e_{t}$ with the answer situation $a_{t}$ into a single vector, with a specific encoding formula as follows:

  $$x_{t}=e_{i}+a_{i}$$

  (25)

• •

  Loss Function: The negative likelihood logit (NLL) was adjusted to MSELoss, and the GKT model was adjusted to be able to predict subjective test scores.