DKVMN
Dynamic Key Value Memory Networks for Knowledge Tracing
view repo
Knowledge Tracing (KT) is a task of tracing evolving knowledge state of students with respect to one or more concepts as they engage in a sequence of learning activities. One important purpose of KT is to personalize the practice sequence to help students learn knowledge concepts efficiently. However, existing methods such as Bayesian Knowledge Tracing and Deep Knowledge Tracing either model knowledge state for each predefined concept separately or fail to pinpoint exactly which concepts a student is good at or unfamiliar with. To solve these problems, this work introduces a new model called Dynamic Key-Value Memory Networks (DKVMN) that can exploit the relationships between underlying concepts and directly output a student's mastery level of each concept. Unlike standard memory-augmented neural networks that facilitate a single memory matrix or two static memory matrices, our model has one static matrix called key, which stores the knowledge concepts and the other dynamic matrix called value, which stores and updates the mastery levels of corresponding concepts. Experiments show that our model consistently outperforms the state-of-the-art model in a range of KT datasets. Moreover, the DKVMN model can automatically discover underlying concepts of exercises typically performed by human annotations and depict the changing knowledge state of a student.
READ FULL TEXT VIEW PDF
Can machines trace human knowledge like humans? Knowledge tracing (KT) i...
read it
Knowledge tracing is the task of modeling each student's mastery of know...
read it
Knowledge Tracing (KT) is to trace the knowledge of students as they sol...
read it
With the increased popularity of electronic textbooks, there is a growin...
read it
With the increased popularity of electronic textbooks, there is a growin...
read it
Knowledge tracing (KT) refers to a machine learning technique to assess ...
read it
Texts present coherent stories that have a particular theme or overall
s...
read it
Dynamic Key Value Memory Networks for Knowledge Tracing
With the advent of massive open online courses and intelligent tutoring systems in the web, students can get appropriate guidance and acquire relevant knowledge in the process of solving exercises. When an exercise is posted, a student must apply one or more concepts to solve the exercise. For example, when a student attempts to solve the exercise “1+2”, then he or she should apply the concept of “integer addition”; when a student attempts to solve “1+2+3.4”, then he or she should apply the concepts of “integer addition” and “decimal addition”. The probability that a student can answer the exercise correctly is based on the student’s
knowledge state, which stands for the depth and robustness of the underlying concepts the student has mastered.The goal of knowledge tracing (KT) is to trace the knowledge state of students based on their past exercise performance. KT is an essential task in online learning platforms. Tutors can give proper hints and tailor the sequence of practice exercises based on the personal strengths and weaknesses of students. Students can be made aware of their learning progress and may devote more energy to less-familiar concepts to learn more efficiently.
Although effectively modeling the knowledge of students has high educational impact, using numerical simulations to represent the human learning process is inherently difficult [22]. Usually, KT is formulated as a supervised sequence learning problem: given a student’s past exercise interactions ,,…,, predict the probability that the student will answer a new exercise correctly, i.e., . Input is a tuple containing the exercise , which student attempts at the timestamp , and the correctness of the student’s answer . We model as observed variables and a student’s knowledge state ,,…, of underlying concepts as a hidden process.
Existing methods such as Bayesian Knowledge Tracing (BKT) [3] and Deep Knowledge Tracing (DKT) [22]
model the knowledge state of students either in a concept specific manner or in one summarized hidden vector, as shown in Figure
1. In BKT, a student’s knowledge state is analyzed into different concept states and BKT models each concept state separately. BKT assumes the concept state as a binary latent variable, known and unknown, and uses a Hidden Markov model to update the posterior distribution of the binary concept state. Therefore, BKT cannot capture the relationship between different concepts. Moreover, to keep the Bayesian inference tractable, BKT uses discrete random variables and simple transition models to describe the evolvement of each concept state. As a result, although BKT can output the student’s mastery level of some predefined concepts, it lacks the ability to extract undefined concepts and model complex concept state transitions.
Besides solving the problem from the Bayesian perspective, a deep learning method named DKT [22]
exploits a variant of recurrent neural networks (RNNs) called long short-term memory (LSTM)
[9]. LSTM assumes a high-dimensional and continuous representation of the underlying knowledge state . The nonlinear input-to-state and state-to-state transitions of DKT have stronger representational power than those of BKT. No human-labeled annotation is required. However, DKT summarizes a student’s knowledge state of all concepts in one hidden state, which makes it difficult to trace how much a student has mastered a certain concept and pinpoint which concepts a student is good at or unfamiliar with [11, 31].The present work introduces a new model called Dynamic Key-Value Memory Networks (DKVMN) that combines the best of two worlds: the ability to exploit the relationship between concepts and the ability to trace each concept state. Our DKVMN model can automatically learn the correlation between input exercises and underlying concepts and maintain a concept state for each concept. At each timestamp, only related concept states will be updated. For instance, in Figure 1, when a new exercise comes, the model finds that requires the application of concept and . Then we read the corresponding concept states and to predict whether the student will answer the exercise correctly. After the student completes the exercise, our model will update these two concept states. All concept states constitute the knowledge state of a student.
In addition, unlike standard memory-augmented neural networks (MANNs) that facilitate a single memory matrix [6, 24, 30] or a variation with two static memory matrices [17, 27], our model has one static matrix called key, which stores the concept representations and the other dynamic matrix called value, which stores and updates the student’s understanding (concept state) of each concept. The terms static and dynamic matrices are respectively analogous to immutable and mutable objects as keys and values in the dictionary data structure (e.g., Python’s dictionary). Meanwhile, our training process is analogous to object creation. After the keys are created, they will be fixed (i.e., immutable) during testing.
The network with two static memory matrices is not suitable for solving the KT task because learning is not a static process. Learning builds upon and is shaped by previous knowledge in human memory [8]. The model with a single dynamic matrix maps the exercise with the correct answer and the exercise with the incorrect answer to different concept states, which does not match our cognition. Experiments show that our DKVMN model outperforms the MANN model with a single memory matrix and the state-of-the-art model.
Our main contributions are summarized as follows:
The utility of MANNs is exploited to better simulate the learning process of students.
A novel DKVMN model with one static key matrix and one dynamic value matrix is proposed.
Our model can automatically discover concepts, a task that is typically performed by human experts, and depict the evolving knowledge state of students.
Our end-to-end trainable model consistently outperforms BKT and DKT on one synthetic and three real-world datasets respectively.
The KT task evaluates the knowledge state of a student based simply on the correctness or incorrectness of a student’s answers in the process of solving exercises . In this study is an exercise tag and is a binary response (1 is correct and 0 is incorrect). No secondary data are incorporated [11].
BKT [3] is a highly constrained and structured model [11]
because it models concept-specific performance, i.e., an individual instantiation of BKT is made for each concept, and BKT assumes knowledge state as a binary variable. Many following variations were raised by integrating personalization study
[19, 33], exercise diversity [20], and other information [4, 23] into the Bayesian framework.DKT [22] exploits the utility of LSTM [9] to break the restriction of skill separation and binary state assumption. LSTM uses hidden states as a kind of summary of the past sequence of inputs, and the same parameters are shared over different time steps. Experiments in [22] showed that DKT outperforms previous Bayesian models by a large margin in terms of prediction accuracy. This study was the first attempt to integrate deep learning models [14, 25]
, which have achieved significant success in other areas, including computer vision
[13]and natural language processing
[16] into KT.Inspired by computer architecture, a particular neural network module called external memory was proposed to enhance the ability of a network to capture long-term dependencies and solve algorithmic problems [7]. MANN have led the progress in various areas, such as question answering [30, 27, 1, 17], natural language transduction [8], algorithm inference [6, 10], and one-shot learning [24, 28].
The typical external memory module contains two parts, a memory matrix that stores the information and a controller that communicates with the environment and reads or writes to the memory. The reading and writing operations are achieved through additional attention mechanisms. Most previous works [6, 27, 24] use a similar way to compute the read weight. For an input
, a cosine similarity or an inner product
of the input and each memory slot is computed, which then goes through a softmax with a positive key strength to obtain a read weight : , where Softmax() = . For the write process, an attention mechanism of focusing both by content and by location is proposed in [6] to facilitate all the locations of the memory. In addition, a pure content-based memory writer named least recently used access (LRUA) module is raised in [24] to write the key either to the least recently used memory location or to the most recently used memory location.Owing to the recurrence introduced in the read and write operations, MANN is a special kind of RNN as well. However, MANN is different from conventional RNNs like the LSTM used in DKT in three aspects. First, traditional RNN models use a single hidden state vector to encode the temporal information, whereas, MANN uses an external memory matrix that can increase storage capacity [30]. Second, the state-to-state transition of traditional RNNs is unstructured and global, whereas MANN uses read and write operations to encourage local state transitions [6]. Third, the number of parameters in traditional RNNs is tied to the size of hidden states [24]. For MANN, increasing the number of memory slots will not increase the number of parameters, an outcome that is more computationally efficient.
In this section, we first introduce the way to exploit the existing MANN model to solve the KT problem. We then show the deficiencies of MANN and describe our DKVMN model. In our description below, we denote vectors with bold small letters and matrices with bold capital letters.
To solve the KT problem, the external memory matrix of MANN is treated as the knowledge state of a student. The overall structure of the model is shown in Figure 1(a). The memory, denoted as , is an matrix, where is the number of memory locations, and is the vector size at each location. At each timestamp , the input for MANN is a joint embedding of , where each comes from a set of distinct exercise tags and is a binary value indicating whether the student answered the exercise correctly. The embedding vector is used to compute the read weight and the write weight .
In our implementation, we choose the cosine similarity attention mechanism to compute and the LRUA mechanism [24] to compute . Details of these two attention mechanisms are shown in the appendix. The intuition of the MANN is that when a student answers the exercise that has been stored in the memory with the same response, will be written to the previously used memory locations and when a new exercise arrives or the student gets a different response, will be written to the least recently used memory locations.
In the read process, the read content is obtained by the weighted sum of all memory slots with the read weight :
(1) |
The output , which is computed from , indicates the probability that the student can answer each exercise correctly in the next timestamp.
In the write process, we first erase unnecessary contents in the memory using the erase signal and the write weight , and then add into the memory using the add signal [6]. For further details, see Section 3.2.3.
MANN uses memory slots to encode the knowledge state of a student and has a larger capacity than LSTM, which only encodes knowledge state in a single hidden vector.
Despite being more powerful than LSTM in storing the past performance of students, MANN still has deficiencies when applied to the KT task. In MANN, the content we read lies in the same space as the content we write. However, for tasks like KT, the input and the prediction, which are the exercises the student receives and the correctness of the student’s answer have different types. Therefore, the way to embed the exercise and the response jointly as the attention key does not make sense. Furthermore, MANN cannot explicitly model the underlying concepts for input exercises. Knowledge state of a particular concept is dispersed and cannot be traced.
To solve these problems, our DKVMN model uses key-value pairs rather than a single matrix for the memory structure. Instead of attending, reading, and writing to the same memory matrix in MANN, our DKVMN model attends input to the key component, which is immutable, and reads and writes to the corresponding value component.
Unlike MANN, at each timestamp, DKVMN takes a discrete exercise tag , outputs the probability of response , and then updates the memory with exercise and response tuple . Here, also comes from a set with distinct exercise tags and is a binary value. We further assume there are latent concepts underlying the exercises. These concepts are stored in the key matrix (of size ) and the student’s mastery levels of each concept, i.e., concept states are stored in the value matrix (of size ), which changes over time.
DKVMN traces the knowledge of a student by reading and writing to the value matrix using the correlation weight computed from the input exercise and the key matrix. The model details are elaborated in the following sections.
The input exercise is first multiplied by an embedding matrix (of size ) to get a continuous embedding vector of dimension . The correlation weight is further computed by taking the softmax activation of the inner product between and each key slot :
(2) |
where Softmax() = and is differentiable. Both the read and write processes will use this weight vector , which represents the correlation between exercise and each latent concept.
When an exercise comes, the read content is retrieved by the weighted sum of all memory slots in the value matrix using :
(3) |
The calculated read content is treated as a summary of the student’s mastery level of this exercise. Given that each exercise has its own difficulty, we concatenate the read content and the input exercise embedding and then pass it through a fully connected layer with a Tanh activation to get a summary vector , which contains both the student’s mastery level and the prior difficulty of the exercise:
(4) |
where Tanh() = .
Finally, is passed through another fully connected layer with a Sigmoid activation to predict the performance of the student:
(5) |
where Sigmoid() = , and is a scalar that represents the probability of answering correctly.
Datasets | Overview | Test AUC (%) | ||||||
---|---|---|---|---|---|---|---|---|
Students | Exercise Tags | Records | BKT | BKT+ | DKT | MANN | DKVMN | |
Synthetic-5 | 4,000 | 50 | 200,000 | 62 | 80 | 80.30.1 | 81.00.1 | 82.70.1 |
ASSISTments2009 | 4,151 | 110 | 325,637 | 63 | - | 80.50.2 | 79.70.1 | 81.60.1 |
ASSISTments2015 | 19,840 | 100 | 683,801 | 64 | - | 72.50.1 | 72.30.2 | 72.70.1 |
Statics2011 | 333 | 1,223 | 189,297 | 73 | 75 | 80.20.2 | 77.60.1 | 82.80.1 |
After the student answers the question , the model will update the value matrix according to the correctness of the student’s answer. A joint embedding of will be written to the value part of the memory with the same correlation weight used in the read process.
The tuple is embedded with an embedding matrix of size to obtain the knowledge growth of the student after working on this exercise. When writing the student’s knowledge growth into the value component, the memory is erased first before new information is added [6], a step inspired by the input and forget gates in LSTMs.
Given a write weight (which is the correlation weight in our model), an erase vector is computed from :
(6) |
where the transformation matrix is of shape , is a column vector with elements that all lie in the range . The memory vectors of value component from the previous timestamp are modified as follows:
(7) |
where is a row-vector of all 1-s. Therefore, the elements of a memory location are reset to zero only if both the weight at the location and the erase element are one. The memory vector is left unchanged if either the weight or the erase signal is zero.
After erasing, a length add vector is used to update each memory slot:
(8) |
where the transformation matrix is of shape and is a row vector. The value memory is updated at each time by
(9) |
This erase-followed-by-add mechanism allows forgetting and strengthening concept states in the learning process of a student.
The overall model architecture is shown in Figure 1(b). During training, both embedding matrices and , as well as other parameters and the initial value of and are jointly learned by minimizing a standard cross entropy loss between and the true label .
(10) |
Our DKVMN model is fully differentiable and can be trained efficiently with stochastic gradient descent (see Section 4.2 for more details).
The prediction accuracy is first evaluated by comparing our DKVMN model with other methods on four datasets, namely one synthetic dataset and three real-world datasets, collected from online learning platforms. Then, comparative experiments of different dimensions of states are performed on DKVMN and DKT for further model exploration. Finally, the ability of our model is verified to discover concepts automatically and depict the knowledge state of students.
The experiment results lead to the following findings:
DKVMN outperforms the standard MANN and the state-of-the-art method on four datasets.
DKVMN can produce better results with fewer parameters than DKT.
DKVMN does not suffer from overfitting, which is a big issue for DKT.
DKVMN can discover underlying concepts for input exercises precisely.
DKVMN can depict students’ concept states of distinct concepts over time.
We implement the models using MXNet [2] on a computer with a single NVIDIA K40 GPU.
To evaluate performance, we test KT models on four datasets: Synthetic-5, ASSISTments2009, ASSISTments2015, and Statics2011.
Synthetic-5: This dataset^{1}^{1}1Synthetic-5:https://github.com/chrispiech/DeepKnowledgeTracing/tree/master/data/synthetic simulates 2000 virtual students answering 50 exercises in both the training and testing dataset. Each exercise is drawn from one of five hidden concepts and has different levels of difficulty. We have no access to the underlying concept labels in the training process and simply use them as the ground truth to evaluate the discovered concept results using our DKVMN model.
ASSISTments2009: This dataset [5] is gathered from the ASSISTments online tutoring platform. Owing to duplicated record issues [32], an updated version is released and all previous results on the old dataset are no longer reliable. The experiments in our paper are conducted using the updated “skill-builder” dataset^{2}^{2}2ASSISTments2009:https://sites.google.com/site/assistmentsdata/home/assistment-2009-2010-data/skill-builder-data-2009-2010. Records without skill names are discarded in the preprocessing. Thus, the number of records in our experiments is smaller than that in [32]. A total of 4,151 students answer 325,637 exercises along with 110 distinct exercise tags.
ASSISTments2015: ASSISTments2015^{3}^{3}3ASSISTments2015:https://sites.google.com/site/assistmentsdata/home/2015-assistments-skill-builder-data only contains student responses on 100 skills. After preprocessing (removing the value of correct ), 683,801 effective records from 19,840 students are remained in this dataset. Each problem set in this dataset has one associated skill. Although this dataset has the largest number of records, the average records for each student are the lowest.
Statics2011: Statics^{4}^{4}4Statics2011:https://pslcdatashop.web.cmu.edu/DatasetInfo?datasetId=507 is from a college-level engineering statics course with 189,297 trials, 333 students and 1,223 exercises tags [26, 12]. In our experiments, a concatenation of problem name and step name is used as an exercise tag; thus it has the maximum number of exercise tags and the maximum number of average records per student.
The complete statistical information for all datasets can be found in Table 1.
Model | Synthetic-5 | ASSISTments2009 | ASSISTments2015 | Statics2011 | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
s. | m. | test | p. | s. | m. | test | p. | s. | m. | test | p. | s. | m. | test | p. | |
dim | size | auc | num | dim | size | auc | num | dim | size | auc | num | dim | size | auc | num | |
DKT | 10 | - | 80.06 | 2.4K | 10 | - | 80.38 | 4.3K | 10 | - | 72.40 | 4.0K | 10 | - | 78.12 | 39K |
50 | - | 80.22 | 28K | 50 | - | 80.53 | 37K | 50 | - | 72.52 | 36K | 50 | - | 79.86 | 205K | |
100 | - | 80.34 | 96K | 100 | - | 80.51 | 114K | 100 | - | 72.49 | 111K | 100 | - | 80.16 | 449K | |
200 | - | 80.32 | 352K | 200 | - | 80.43 | 388K | 200 | - | 72.45 | 382K | 200 | - | 80.20 | 1.0M | |
DKVMN | 10 | 50 | 82.00 | 12K | 10 | 10 | 81.47 | 7k | 10 | 20 | 72.68 | 14K | 10 | 10 | 82.72 | 92K |
50 | 50 | 82.66 | 25K | 50 | 20 | 81.57 | 31k | 50 | 10 | 72.66 | 29K | 50 | 10 | 82.84 | 197K | |
100 | 50 | 82.73 | 50K | 100 | 10 | 81.42 | 68k | 100 | 50 | 72.64 | 63K | 100 | 10 | 82.71 | 338K | |
200 | 50 | 82.71 | 130K | 200 | 20 | 81.37 | 177k | 200 | 50 | 72.53 | 153K | 200 | 10 | 82.70 | 649K |
The input exercise data are presented to neural networks using “one-hot” input vectors. Specifically, if different exercises exist in total, then the exercise tag for the key memory part is a length vector whose entries are all zero except for the entry, which is one. Similarly, the combined input for the value matrix component is a length vector, where entry is one.
We learn the initial value of both the key and the value matrix in the training process. Each slot of the key memory is the concept embedding and is fixed in the testing process. Meanwhile, the initial value of the value memory is the initial state of each concept, which represents the initial difficulty of each concept.
Of all the datasets, 30% of the sequences were held out as a testing set, except for the synthetic dataset where training and testing datasets had the same size. A total 20% of the training set was split to form a validation set, which was used to select the optimal model architecture and hyperparameters and perform early stopping
[18].The parameters were initialized randomly from a Gaussian distribution with zero mean and standard deviation
. The initial learning rate was case by case because the number of students, exercise tags, and total answers per dataset varied, but the learning rateannealed every 20 epochs by
until the 100th epoch was reached.We used LSTM for DKT in our implementation. The standard MANN was implemented using the cosine similarity reading attention mechanism and the LRUA writing attention mechanism. Stochastic gradient descent with momentum and norm clipping [21] were used to train DKT, MANN, and our DKVMN in all the experiments. We consistently set the momentum to be and the norm clipping threshold to be . Given that input sequences are of different lengths, all sequences were set to be a length of (for synthetic with a length of
) and a null symbol was used to pad short sequence to a fixed size of
.In all cases, hyperparameters were tuned using the five-fold cross validation. The test area under the curve (AUC) was computed using the model with the highest validation AUC among the 100 epochs. We repeated each training five times with different initializations and reported the average test AUC along with the standard deviation.
The AUC is measured to evaluate the prediction accuracy on each dataset. An AUC of represents the score achievable by random guessing. A high AUC score accounts for a high prediction performance. Results of the test AUC on all datasets are shown in Table 1.
We compare the DKVMN model with the MANN baseline, the state-of-the-art DKT, the standard BKT model, and, when possible, optimal variations of BKT (BKT+). An interesting observation is that our implemented LSTM achieves better AUC than those in the original papers [22, 11, 32]. The reason may be that our implementations use norm clipping and early stopping, both of which improve the overfitting problem of LSTM. The results of BKT are directly obtained from recent works [11, 32].
On the Synthetic-5 dataset, the DKVMN model achieves the average test AUC of 82.7%. In our simulation, each exercise is treated as having a distinct skill label. MANN produces an average AUC of 81.0%. DKT produces an AUC value of 80.3%, which is better than the 75% reported in the original paper [22, 11]. BKT and its variant model achieve the AUC of 62% and 80% respectively [11]. The prediction results of DKVMN from the ASSISTments2009 achieve improvement over MANN, DKT, and BKT with 81.6% over 79.7%, 80.5%, and 63% respectively [32]. As this dataset is preprocessed differently from that in [32], their results are not comparable. On the ASSISTments2015 dataset, the test AUC of DKVMN is 72.7%, which is better than 72.3% for MANN, 72.5% for DKT (originally 70% in [32]), and 64% for classic BKT [32]. With regard to Statics2011, which has the maximum number of exercise tags and the minimum number of answers, classical BKT gains the AUC of 73% and BKT cooperating with forgetting, skill discovery, and latent abilities obtains an AUC of 75% [11]. Our implemented DKT leads to an AUC of 80.2%, which is better than the 76% from [11]. MANN only produces the average AUC of 77.6%. However, our DKVMN model achieves an AUC of 82.8%, outperforming all previous models.
In summary, DKVMN performs better than other methods across all the datasets, particularly on the Statics2011 dataset whose number of distinct exercises is large. This result demonstrates that our DKVMN can model student’s knowledge well when the number of exercises is very large.
DKVMN can achieve better prediction accuracy over student exercise performance and also requires considerably fewer parameters than the DKT model because of its large external memory capacity. Table 2 compares the DKVMN model with the DKT model using LSTM by traversing different hyperparameters. The table reveals that DKVMN with low state dimensions can achieve better prediction accuracy than DKT with high state dimensions. For instance, on the Statics2011 dataset, DKT reaches the maximum test AUC of 80.20% when the dimension of states equals 200 using 1 million parameters. Meanwhile, DKVMN can achieve the test AUC of 82.84% only with 50 state dimensions using 197 thousand parameters.
Moreover, the DKT model suffers severe overfitting, whereas our DKVMN model does not confront such a problem. As indicated in Figure 3, no huge gap exists between the training AUC and the validation AUC of DKVMN, and the validation AUC of DKVMN increases smoothly. However, as the epoch proceeds, the training AUC of DKT increases continuously, and the validation AUC of DKT only increases in the first several epochs and begins to decrease.
Our DKVMN model has the power to discover underlying patterns or concepts for exercises using the correlation weight w, which is traditionally annotated by experts. The correlation weight between the exercise and the concept implies the strength of their inner relationship. Compared with the conditional influence approach in [22] which computes the dependencies between exercises and then defines a threshold to cluster the exercises, our model directly assigns exercises to concepts. No predefined threshold is required. As a result, our model can discover the concepts of exercises in an end-to-end manner.
Each exercise is usually associated with a single concept. In this case, we assign the exercise to the concept with the largest correlation weight value. From the experiments, we find that our model can intelligently learn sparse weight among concepts, and the discovered concepts reveal a compelling result.
On the Synthetic-5 dataset, each exercise is drawn from a concept , where , such that the ground truth concept can be accessed for all exercises, as shown on the top x-axis of the heat map in Figure 4. Exercises from the same concept are labeled with squares in the same color. The left heat map in Figure 4 shows the correlation weight between 50 distinct exercises and 5 latent concepts (generated from DKVMN when the memory size is five). Each column represents the correlation weight between an exercise and five latent concepts. For each exercise, the weight is sparse where exactly one value approximates 1 and the others approximate 0. After clustering each exercise to the concept with the maximum weight value, we get the graph shown in the right part of Figure 4, which reveals a perfect clustering of five latent concepts. The adjusted mutual information [29] of our clustering result and the ground truth is 1.0.
Moreover, when the memory size is set to be larger than the ground truth 5, e.g., 50, our model can also end up with 5 exercise clusters and find the appropriate concept for each exercise. Additional results are described in the appendix.
On the ASSISTments2009 dataset, no ground truth concept is used for each exercise. However, the name for each exercise tag can be obtained, as shown in the right part of Figure 5. Each exercise tag is followed by a name. The resulting cluster graph in Figure 5 is drawn using t-SNE [15] by projecting the multi-dimensional correlation weights to the 2-D points. All exercises are grouped into 10 clusters, where the exercises from the same cluster (concept) are labeled in the same color. The clustering graph reveals many reasonable results. Some related exercises are close to one another in the cluster. For example, in the first cluster, Ordering Fractions, Ordering Integers, Ordering Positive Decimals, and Ordering Real Numbers are clustered together, which exposes the concept of elementary arithmetic.
Our DKVMN can also be used to depict the changing knowledge state of students. Depicting the knowledge state, especially each concept state, is helpful for the users on online learning platforms. If students possess their concept states of all concepts, which pinpoint their strengths and weaknesses, they will be more motivated to fill in the learning gaps independently. A student’s changing knowledge state can be obtained in the read process using the following steps.
First, the content in the value component is directly used as the read content in Eq.(3), which can be accessed by setting the correlation weight to be , where of concept is equal to 1.
Then, we mask the weight of the input content embedding in Eq.(4) to ignore the information of exercises:
(11) |
where is split into two parts and , and let .
Finally, we compute the scalar as in Eq.(5) to be the predictive mastery level of a concept (concept state).
Figure 6 shows an example of depicting a student’s five changing concept states. The first column represents the initial state of each concept before the student answers any exercise, such state differs from concept to concept. Owing to our model’s ability to discover concepts for each exercise, each time the student answers an exercise, the concept state of the discovered concept will increase or decrease. For example, when the student answers the first three exercises correctly, concept states of the second and fifth concepts increase; when the student answers the fourth exercise incorrectly, the concept state of the third concept decreases. After answering 50 exercises, the student is shown to have mastered the second, third, and fourth concepts but failed to understand the fifth concept.
This work proposes a new sequence learning model called DKVMN to tackle the KT problem. The model can be implemented in online learning platforms to improve the study efficiency of students. DKVMN not only outperforms the state-of-the-art DKT but can also trace a student’s understanding of each concept over time, which is the main drawback of DKT. Compared with standard MANNs, the key-value pair allows DKVMN to discover underlying concepts for each input exercise and trace a student’s knowledge state of all concepts.
For future work, we will incorporate content information into the exercise and concept embeddings to further improve the representations. We will also investigate a hierarchical key-value memory networks structure which can encode the hierarchical relationship between concepts.
The work described in this paper was partially supported by the Research Grants Council of the Hong Kong Special Administrative Region, China (No. CUHK 14208815 of the General Research Fund) and Ministry of Education of China (D.01.16.00101).
When memory size is set to 50 for the synthetic-5 dataset, the exercises can still be clustered into five categories. The heat map in Figure 7 describes all correlation weight vectors, which only fall into several concepts. After clustering each exercise to the concept with the maximum weight value, the adjusted mutual information of our clustering result and the ground truth is 0.879. Additionally, if we cluster using t-SNE (in Figure 7), then the adjusted mutual information will be 1.0, which reveals a perfect result.
For each input key , we compute the cosine similarity of the key and memory:
(12) |
which is then used to compute the read weight through a softmax with a positive key strength :
(13) |
The LRUA model [24] writes the keys either to the least used memory location or the most recently used memory location.
First, a usage weight vector is used to record the usage frequency of all memories: The usage weights are updated at each time-step by decaying the previous usage weights and adding the current reading and writing weights:
(14) |
where is a decay parameter. is fixed to be 0.9 in our implementation. Then the least-used weight is defined to record the least-used memories using a notation , which denotes smallest element of the vector ,
(15) |
where is set to equal the number of reads to memory.
Now the write weight is the convex combination of the previous read weights and previous least-used weights:
(16) |
where
is a sigmoid function, and
is a scalar gate parameter to interpolate between two weights.
Mxnet: A flexible and efficient machine learning library for heterogeneous distributed systems.
In In Neural Information Processing Systems, Workshop on Machine Learning Systems, 2015.More accurate student modeling through contextual estimation of slip and guess probabilities in bayesian knowledge tracing.
In International Conference on Intelligent Tutoring Systems, pages 406–415. Springer, 2008.Modeling individualization in a bayesian networks implementation of knowledge tracing.
In User Modeling, Adaptation, and Personalization, pages 255–266. Springer, 2010.International Journal of Artificial Intelligence in Education
, 14(1):63–96, 2004.
Comments
There are no comments yet.