Pith. sign in

REVIEW 6 major objections 5 minor 62 references

Denoising Programming Knowledge Tracing with a Code Graph-based Tuning Adaptor

T0 review · 6 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Coda, a code graph-based tuning adaptor, improves programming knowledge tracing by identifying and correcting noisy submissions.

desk verdict A useful, model-agnostic PKT denoising framework with plausible gains, but the main noise-identification heuristic looks inverted as written and the adaptor equations do not type-check. read the letter →

arxiv 2506.11107 v1 pith:QXIPR2BL submitted 2025-06-07 cs.SE cs.AI

Weibo Gao , Qi Liu , Rui Li , Yuze Zhao , Hao Wang , Linan Yre , Fangzhou Yao , Zheng Zhang This is my paper
classification cs.SEcs.AI
keywords programmingknowledgetracingcodegraphnoiseidentificationdenoisingconvolutionalnetworklow-rankadaptationstatecorrectionnext-attemptprediction
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Programming knowledge tracing (PKT) models infer a learner's mastery of programming concepts from their submission history, but real practice logs contain records that do not reflect knowledge: throwaway submissions testing the environment, code pasted into the wrong question, and strings of minor edits that leave understanding unchanged. The paper claims these two noise types, unwanted and weak signals, systematically mislead existing PKT models, and proposes Coda, a model-agnostic layer that spots them and repairs the damage. Coda builds a per-learner code graph whose edges encode semantic similarity between submissions, flags isolated nodes that are also dissimilar to correct solutions of the practiced question as unwanted, and uses a cluster-aware graph network plus K-means to group near-duplicate submissions around a core attempt as weak. A lightweight low-rank adaptor then tunes a frozen PKT backbone, with losses that pull the knowledge state after an unwanted submission back to the previous related state and keep the state flat across weak submissions. On four real datasets, attaching Coda to five existing PKT models improves next-attempt prediction accuracy over the unmodified baselines.

What carries the argument

The load-bearing object is the per-learner code graph $G_u$: each submission is a node, and edges come from a learnable metric (weighted cosine similarity) with a ranking-based sparsity mask. On this graph, unwanted-signal identification uses node isolation plus a comparison of the similarity distribution $S_i$ to the question's correct solutions, where a mean below the median marks a code as unrelated; weak-signal identification runs a cluster-aware GCN that aggregates neighbors with attention computed from $k$-hop cluster neighborhoods, then applies K-means and treats the earliest submission of each cluster as the core. The tuning side is a low-rank adaptor (two trainable matrices $W_A$, $W_B$) that reads a prompt encoding the identified signal type and adds a correction to the backbone's knowledge state, optimized with the noise-feature losses $\mathcal{L}_{uw}$ and $\mathcal{L}_{weak}$ and the navigational regularization upper bound of Eq. (13).

What would settle it

Take a dataset of programming submissions with ground-truth noise labels, or construct one by injecting unrelated snippets and near-duplicate edits into clean sequences, run Coda's identification stage, and compare predicted noise labels to the ground truth. If a substantial fraction of question-related isolated codes have mean($S_i$) < median($S_i$) for their solution similarities, they are being marked as unwanted, and the claimed denoising benefit would be achieved partly by discarding genuine attempts; the central claim would fail if removing the mean-below-median rule improves or does not hurt prediction accuracy.

Watch

Extended reading notes

Core claim

The central claim is that noisy programming submissions are identifiable from semantic structure alone and that correcting for them improves PKT. Concretely, the paper argues that for any learner, unrelated submissions are both isolated in the code graph and have similarity scores to the question's correct solutions whose mean falls below their median; minor-modification submissions cluster around an earlier 'core' submission under cluster-aware graph convolution followed by K-means. Using these identifications as prompts, a LoRA-style adaptor (two trainable rank-decomposition matrices) added to the frozen code encoder and knowledge estimator produces a correction signal that is added to the knowledge state, with KL-divergence constraints enforcing that unwanted submissions do not move the state and weak submissions keep it close to the core state, plus a navigational regularization term bounding the batch-to-batch change of prediction loss. The paper maintains that this makes Coda a general, computationally light denoising layer that plugs into most existing PKT solutions, and its experiments report consistent gains in AUC, F1, and RMSE over typical baselines on BePKT, AtCoder, and their single-language subsets.

Load-bearing premise

The claim rests on the assumption that an isolated submission is unwanted exactly when the mean of its similarities to correct solutions falls below the median, a rule that can mislabel relevant codes whose similarity distribution is merely skewed by a few outliers.

Editorial extensions

If this is right

  • Attaching Coda to a trained PKT model improves next-attempt prediction on the four evaluated datasets; for example, on BePKT_C++ the F1 of PST rises from 28.57% to 37.40%.
  • Each design component contributes: ablations that remove the isolation check, the solution-similarity check, the unwanted-signal loss, the GCN, the weak-signal loss, or the navigational regularization all reduce performance on BePKT_C++.
  • Longer, noisier programming sequences benefit more, since models on the multi-language and longer-sequence datasets show clearer gains, consistent with the paper's noise-motivated design.
  • Knowledge-state traces become more stable: the Coda-X models do not drop proficiency at unrelated submissions or minor edits where the baseline PKT models underestimate learners.
  • The framework is model-agnostic: it runs on top of DKT+, PDKT, Code-DKT, Help-DKT, and PST using the same identification and tuning procedure, without retraining the backbone.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The paper does not validate its noise labels against ground truth, so a natural extension is to measure precision and recall of the identification stage on data where noise is known; the mean-below-median rule is a likely failure point because relevant codes with a few very dissimilar outliers will satisfy that inequality.
  • The navigational regularization enforces an upper bound rather than the true batch-to-batch loss change, so it may not actually guarantee monotonic improvement; it is plausible that the reported stability comes mostly from the low-rank adaptor's constrained correction rather than from this term.
  • The same two noise types appear in other multi-submission learning settings, such as essay revision or open-ended mathematics solutions, so Coda's machinery, which only needs content embeddings and a per-learner sequence, could transfer there even though the paper does not claim this.
  • Because code graph construction is quadratic in sequence length, Coda's reported gains on datasets with tens of submissions per learner may not carry over to much longer programming histories; an incremental or sliding-window graph construction would be a testable extension.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

6 major / 5 minor

Summary. The paper proposes Coda, a model-agnostic denoising stage for programming knowledge tracing (PKT). Coda first converts each learner's submission sequence into a code graph with learned similarities (Eqs. 3-4), identifies "unwanted" submissions that are both isolated and insufficiently similar to correct solutions (Eq. 5 and the mean/median rule in §3.1.2), and identifies "weak" submissions by applying a cluster-aware GCN plus K-means and treating the earliest submission in each cluster as the core signal (§3.1.3). It then freezes a trained PKT backbone and tunes a low-rank adaptor that adds a correction to the knowledge state (Eq. 8), using two KL-based constraints (Eqs. 9-10) and a navigational regularization (Eqs. 12-13). Experiments compare Coda-X against five PKT backbones on BePKT, AtCoder, BePKT_C++, and AtCoder_C, reporting consistent improvements in AUC, F1, and RMSE.

Significance. If the mechanism works as intended, Coda would be the first denoising layer for PKT, and the paper's strengths include the model-agnostic framing, the breadth of backbones and datasets, and the released code. The empirical gains are consistent across tables, and the ablation study attributes most of the gain to the weak-signal identification component. However, several load-bearing formalisms in the method description are either ill-defined or internally inconsistent, so the current text does not yet establish that the reported gains come from the proposed denoising mechanism.

major comments (6)
  1. [§3.1.2, Eq. (5), Algorithm 2 lines 21-22] The rule "mean(S_i) < median(S_i) ⇒ irrelevant" is, as written, likely inverted. For a code genuinely related to the question, its similarities to the accepted solutions are often left-skewed (high similarity to many solutions, low similarity to a few stylistically different ones), giving mean < median; an unrelated code has uniformly low similarities, giving mean ≈ median. Thus the stated rule would discard relevant submissions and retain unrelated ones. The authors need to justify this heuristic with empirical similarity distributions, or replace it with a more defensible criterion (e.g., a quantile or threshold on maximum similarity). Since this rule feeds the removal of nodes and the loss in Eq. (9), it is load-bearing for the whole denoising claim.
  2. [§3.2.1, Eq. (8)] The correction signal is defined as (W_A^T W_B) ⊙ p_u,t. Since W_A ∈ R^{b×2d'} and W_B ∈ R^{b×2d'}, the product is in R^{2d'×2d'}; p_u,t is a vector in R^{2d'}. The Hadamard product of a matrix and a vector is not defined, and even if interpreted as (W_A^T W_B) p_u,t the result is 2d'-dimensional, whereas h_u,t and h'_u,t are d-dimensional (with d'=d per §4.2.3). Please specify how the 2d'-dimensional prompt is projected to the d-dimensional state space, or redefine the adaptor matrices so that Eq. (8) is dimensionally sound.
  3. [§3.1.2-§3.1.3 and §3.2] The pipeline removes unwanted nodes from V_u before applying the GCN (Eq. 6), so no updated representation x'_u,r exists for an unwanted node. Yet §3.2 constructs the unrelated prompt from Wp ⊙ x'_u,r. The authors should state explicitly whether the original x_u,r, the masked W⊙x_u,r, or some other representation is used; as written, the prompt for the unrelated case references a quantity that is not produced by the described algorithm.
  4. [§3.2.1, Eqs. (9)-(10)] KL divergence is applied directly to knowledge state vectors h'_{u,t}, h'_{u,t+}, and h'_{u,core}. These vectors are arbitrary real-valued hidden states, not probability distributions. The manuscript must specify how they are converted to distributions (e.g., softmax or Gaussian parameterization) or use a different divergence/distance. Without this specification, the two constraint losses in Eq. (11) are not computable as written.
  5. [Algorithm 3, lines 23-26] The pseudo-code computes an intermediate θ_b from the prediction loss L_p "without gradient backpropagating", then updates the actual parameters using only ∇_θ L_nav_b. This means the adaptor is not optimized on the PKT prediction loss (or on L_Coda = L_p + L_nav_b) at all, which contradicts Eq. (14) and the description in §3.2. The algorithm should be corrected to backpropagate the total loss, or if the intermediate θ_b is only for evaluating L_nav, the actual update should be on L_Coda.
  6. [§3.2.2, Eqs. (12)-(13)] The stated goal is that accuracy "should not be worse" after a batch, but Eq. (12) penalizes |L(θ_b)-L(θ_{b-1})|, i.e., it also penalizes improvements. A one-sided hinge, max(0, L(θ_b)-L(θ_{b-1})), would match the stated goal. In addition, Property 1 claims an upper bound, but the proof uses a Taylor expansion with a Hessian approximation H≈2J^TJ; that is an approximation, not a bound. Either provide a genuine bound or rephrase the claim.
minor comments (5)
  1. [§2.1 / §4.2.2] The text says ACC, AUC, and RMSE are used, but Table 1 reports F1-score instead of ACC. Please align the text and table.
  2. [§3.4] The complexity analysis says the code graph is constructed only once per learner during training, but Eq. (3) makes the graph depend on the trainable W and Algorithm 3 constructs the graph at every training batch. Please clarify what "once" means (e.g., once per epoch with the current W).
  3. [Eq. (6)] The residual addition x'_{u,i}=x^{(L)}_{u,i}+x_{u,i} requires x^{(L)} and x_{u,i} to have the same dimension; the paper states d'=d only later in §4.2.3. State this requirement before Eq. (6).
  4. [Algorithm 3, line 19] The notation M_PKT(l_{u,1:t}; h'_{u,t}) assumes the backbone can accept an externally supplied knowledge state; this interface should be defined in Section 2.2.
  5. [Table 3] In the ablation study, the "w/o gcn" variant removes Eq. (6) but still uses K-means on the original embeddings; the text should say whether the cluster-aware attention in Eq. (7) is also removed in that variant.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central denoising claim is validated on held-out next-attempt prediction, and noise labels are intermediate modeling constructs rather than the prediction target.

full rationale

Coda's advertised result is improved next-attempt performance on held-out test sequences, measured by ACC/AUC/RMSE and cross-entropy (Eq. 2, Table 1). This is an external benchmark, not a quantity constructed from the noise labels. The unwanted/weak labels are intermediate outputs of the code graph construction and K-means clustering (Section 3.1); the adaptor losses in Eqs. (9)-(10) encode consistency assumptions between corrected knowledge states, not a direct substitution of the prediction with the labels. The graph-construction weights W, W_c, W_p and LoRA matrices W_A, W_B are trained with the same prediction objective plus regularizers, and no fitted parameter is renamed as a prediction. Self-citations such as [46] and [49] are bibliographically related but are not invoked as the unique justification for the central claim, and no uniqueness theorem is imported from the authors' prior work. The mean(S_i) < median(S_i) rule in Section 3.1.2 is unexplained and potentially inverted, but that is a heuristic-correctness concern, not a circularity: the rule does not make the reported prediction equal to its input by construction. Therefore no circular step is established.

Assumptions & free parameters 9 free parameters · 5 assumptions · 0 invented entities

The central claim rests on the code-graph similarity assumptions, the heuristic noise-labeling rules, and the unspecified dimension compatibility of the adaptor. The framework does not introduce new physical entities, but it does rely on several ad hoc modeling choices that are not validated against ground-truth noise labels.

free parameters (9)
  • W (metric vector)
    Trainable vector in Eq. (3) that reweights code embedding dimensions for similarity computation; learned during training.
  • W_a (GCN weight matrix)
    Linear transformation in Eq. (6) for the cluster-aware GCN; learned during training.
  • W_c (attention vector)
    Transform vector in Eq. (7) for computing cluster-aware attention; learned during training.
  • W_p (prompt transform vector)
    Transform vector in Section 3.2 that converts code representations into prompts; learned during training.
  • W_A, W_B (adaptor matrices)
    Low-rank matrices in Eq. (8) for the tuning adaptor; learned during training.
  • epsilon (graph sparsity) = searched in 0.2/0.4/0.5/0.6/0.8 of T_u^2
    Hyperparameter in Eq. (4) controlling graph sparsity; tuned on validation, not fitted by gradient.
  • C_k (number of clusters) = searched in 1, 3, 5
    K-means cluster count in Section 3.1.3; tuned on validation.
  • learning rate = searched in 1e-3, 1e-2, 1e-1
    Per-model learning rate; tuned on validation.
  • b (adaptor rank) = d'/2
    Rank of the LoRA-style adaptor in Eq. (8); set by the authors, not fitted.
assumptions (5)
  • domain assumption CodeBERT embeddings preserve semantic similarity between submitted codes and correct solutions.
    The unwanted-signal identification in Section 3.1.2 relies on similarity between isolated codes and correct solutions (Eq. 5); if CodeBERT embeddings do not encode question relevance, the identification fails.
  • ad hoc to paper The mean < median heuristic correctly discriminates relevant from irrelevant submissions.
    Section 3.1.2 uses this empirical rule without justification or validation against labeled noise; it appears logically inverted and is load-bearing for unwanted-signal removal.
  • ad hoc to paper The earliest submission in each K-means cluster is the core signal.
    Section 3.1.3 defines the earliest submission in a cluster as core and the rest as weak; if this is wrong, the weak-signal loss in Eq. (10) anchors knowledge states to incorrect references.
  • domain assumption The backbone PKT knowledge-state dimension matches the adaptor output dimension.
    Eq. (8) adds a 2d'-dimensional correction to the d-dimensional knowledge state (with d'=d); the paper never states how this dimension mismatch is resolved.
  • standard math The Gauss-Newton approximation of the Hessian yields a valid upper bound for the navigation loss.
    The proof in Appendix A approximates H by 2 J^T J; this is a standard but inexact approximation, so Property 1 is an approximate bound, not an exact inequality.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Denoising Programming Knowledge Tracing with a Code Graph-based Tuning Adaptor." pith.science (2026). https://pith.science/paper/QXIPR2BL

@misc{pith2026250611107,
  author       = {Pith},
  title        = {Pith review of: Denoising Programming Knowledge Tracing with a Code Graph-based Tuning Adaptor},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QXIPR2BL}},
  note         = {Machine review of arXiv:2506.11107}
}
read the original abstract

Programming Knowledge Tracking (PKT) aims to dynamically diagnose learners' mastery levels of programming knowledge based on their coding activities, facilitating more effective and personalized programming education. However, current PKT studies primarily focus on the implicit relationship between code content and knowledge assessment, often overlooking two types of noise signals in long-term programming activities: unwanted signals from unrelated submissions and weak signals from minor modifications. This practical challenge significantly limits model performance and application. To address this issue, we propose Coda, a Code graph-based tuning adaptor designed to enhance existing PKT models by identifying and mitigating the impact of noise. Specifically, Coda first transforms the loose code sequences submitted by each learner into a compact code graph. By leveraging this code graph, unwanted signals can be identified from a semantic similarity perspective. We then apply a cluster-aware GCN to the code graph, which improves the discrimination of weak signals and enables their clustering for identification. Finally, a lightweight yet effective adaptor is incorporated into the PKT task through optimization with two noise feature-based constraints and a navigational regularization term, to correct knowledge states affected by noise. It is worth mentioning that the Coda framework is model-agnostic and can be adapted to most existing PKT solutions. Extensive experimental results on four real-world datasets demonstrate that Coda effectively performs the PKT task in the presence of noisy programming records, outperforming typical baselines.

Figures

Figures reproduced from arXiv: 2506.11107 by the authors.

Figure 1
Figure 1. The example of the programming practice process, [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. At each attempt of the programming practice sequence [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. The overall architecture of Coda. Left shows the stage for noisy signal identification, where (b) aims to find unwanted [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Visualization of Code-X and original PKT models tracing knowledge of a learner along the practice sequence. [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]
Figure 5
Figure 5. Figure 5: Performance under different sparse levels of the [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

62 extracted references · 41 canonical work pages

  1. [1]

    Alexander A Alemi, Ian Fischer, Joshua V Dillon, and Kevin Murphy. 2016. Deep variational information bottleneck.arXiv preprint arXiv:1612.00410(2016)

    arXiv 2016

  2. [2]

    Uri Alon, Meital Zilberstein, Omer Levy, and Eran Yahav. 2018. code2vec: Learn- ing Distributed Representations of Code. arXiv:1803.09473 [cs.LG]

    arXiv 2018

  3. [3]

    Jianxin Chang, Chen Gao, Yu Zheng, Yiqun Hui, Yanan Niu, Yang Song, Depeng Jin, and Yong Li. 2021. Sequential recommendation with graph neural networks. InProceedings of the 44th international ACM SIGIR conference on research and development in information retrieval. 378–387

    2021

  4. [4]

    Yu Chen, Lingfei Wu, and Mohammed Zaki. 2020. Iterative deep graph learning for graph neural networks: Better and robust node embeddings.Advances in neural information processing systems33 (2020), 19314–19326

    2020

  5. [5]

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. CodeBERT: A Pre-Trained Model for Programming and Natural Languages. arXiv:2002.08155 [cs.CL]

    arXiv 2020

  6. [6]

    Weibo Gao, Qi Liu, Zhenya Huang, Yu Yin, Haoyang Bi, Mu-Chun Wang, Jianhui Ma, Shijin Wang, and Yu Su. 2021. Rcd: Relation map driven cognitive diagnosis for intelligent education systems. InProceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval. 501–510

    work page 2021

  7. [7]

    Weibo Gao, Qi Liu, Hao Wang, Linan Yue, Haoyang Bi, Yin Gu, Fangzhou Yao, Zheng Zhang, Xin Li, and Yuanjing He. 2024. Zero-1-to-3: Domain-Level Zero- Shot Cognitive Diagnosis via One Batch of Early-Bird Students towards Three Diagnostic Objectives. InProceedings of the AAAI Conference on Artificial Intelli- gence, Vol. 38. 8417–8426

    work page 2024

  8. [8]

    Aritra Ghosh, Neil Heffernan, and Andrew S Lan. 2020. Context-aware atten- tive knowledge tracing. InProceedings of the 26th ACM SIGKDD international conference on knowledge discovery & data mining. 2330–2339

    work page 2020

Show all 62 references
  1. [9]

    Xavier Glorot and Yoshua Bengio. 2010. Understanding the difficulty of training deep feedforward neural networks. InProceedings of the thirteenth international conference on artificial intelligence and statistics. JMLR Workshop and Conference Proceedings, 249–256

    2010

  2. [10]

    Siqi Han, Yu Wang, and Xuesong Lu. 2023. ErrorCLR: Semantic Error Classi- fication, Localization and Repair for Introductory Programming Assignments. InProceedings of the 46th International ACM SIGIR Conference on Research and Development in Information Retrieval. 1345–1354

    2023

  3. [11]

    John A Hartigan and Manchek A Wong. 1979. Algorithm AS 136: A k-means clustering algorithm.Journal of the royal statistical society. series c (applied statistics)28, 1 (1979), 100–108

    1979

  4. [12]

    Jonathan Ho, Ajay Jain, and Pieter Abbeel. 2020. Denoising diffusion probabilistic models.Advances in neural information processing systems33 (2020), 6840–6851

    2020

  5. [13]

    Sepp Hochreiter and Jürgen Schmidhuber. 1997. Long short-term memory.Neural computation9, 8 (1997), 1735–1780

    1997

  6. [14]

    Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. Lora: Low-rank adaptation of large language models.arXiv preprint arXiv:2106.09685(2021)

    2021 arXiv

  7. [15]

    Yilun Jin, Kai Chen, and Qiang Yang. 2023. Transferable graph structure learning for graph-based traffic forecasting across cities. InProceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining. 1032–1043

    2023

  8. [16]

    Jin-Hwa Kim, Kyoung-Woon On, Woosang Lim, Jeonghee Kim, Jung-Woo Ha, and Byoung-Tak Zhang. 2016. Hadamard product for low-rank bilinear pooling. arXiv preprint arXiv:1610.04325(2016)

    2016 arXiv

  9. [17]

    Diederik P Kingma and Jimmy Ba. 2014. Adam: A method for stochastic opti- mization.arXiv preprint arXiv:1412.6980(2014)

    2014 arXiv

  10. [18]

    Philip IS Lei and António José Mendes. 2021. A systematic literature review on knowledge tracing in learning programming. In2021 IEEE Frontiers in Education Conference (FIE). IEEE, 1–7

    2021

  11. [19]

    Haoyang Li, Xin Wang, Ziwei Zhang, Jianxin Ma, Peng Cui, and Wenwu Zhu. 2021. Intention-aware sequential recommendation with structured intent transition. IEEE Transactions on Knowledge and Data Engineering34, 11 (2021), 5403–5414

    2021

  12. [20]

    Mingjia Li, Hong Qian, Jinglan Lv, Mengliang He, Wei Zhang, and Aimin Zhou

  13. [21]

    Ruixin Li, Yu Yin, Le Dai, Shuanghong Shen, Xin Lin, Yu Su, and Enhong Chen

  14. [22]

    Rongfan Li, Ting Zhong, Xinke Jiang, Goce Trajcevski, Jin Wu, and Fan Zhou

  15. [23]

    Yu Liang, Tianhao Peng, Yanjun Pu, and Wenjun Wu. 2022. HELP-DKT: an interpretable cognitive model of how students learn programming based on deep knowledge tracing.Scientific Reports12, 1 (2022), 1–11

    2022

  16. [24]

    Jiayu Liu, Zhenya Huang, Zhiyuan Ma, Qi Liu, Enhong Chen, Tianhuang Su, and Haifeng Liu. 2023. Guiding Mathematical Reasoning via Mastering Commonsense Formula Knowledge. InProceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining. 1477–1488

    2023

  17. [25]

    InProceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining

    Mining spatio-temporal relations via self-paced graph contrastive learning. InProceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining. 936–944

  18. [26]

    Qi Liu, Zhenya Huang, Yu Yin, Enhong Chen, Hui Xiong, Yu Su, and Guoping Hu

  19. [27]

    Shuo Liu, Junhao Shen, Hong Qian, and Aimin Zhou. 2024. Inductive Cognitive Diagnosis for Fast Student Learning in Web-Based Intelligent Education Systems. InProceedings of the ACM on Web Conference 2024. Singapore, 4260–4271

    2024

  20. [28]

    Naiming Liu, Zichao Wang, Richard G Baraniuk, and Andrew Lan. 2022. GPT- based Open-Ended Knowledge Tracing.arXiv preprint arXiv:2203.03716(2022)

    2022 arXiv

  21. [29]

    Andy Nguyen, Christopher Piech, Jonathan Huang, and Leonidas Guibas. 2014. Codewebs: scalable homework search for massive open online programming courses. InProceedings of the 23rd international conference on World wide web. 491–502

    2014

  22. [30]

    Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. 2019. Pytorch: An imperative style, high-performance deep learning library.Advances in neural information processing systems...

    2019

  23. [31]

    Chris Piech, Jonathan Bassen, Jonathan Huang, Surya Ganguli, Mehran Sahami, Leonidas J Guibas, and Jascha Sohl-Dickstein. 2015. Deep knowledge tracing. Advances in neural information processing systems28 (2015)

    2015

  24. [32]

    Haiping Ma, Yong Yang, Chuan Qin, Xiaoshan Yu, Shangshang Yang, Xingyi Zhang, and Hengshu Zhu. 2024. HD-KT: Advancing Robust Knowledge Tracing via Anomalous Learning Interaction Detection. InProceedings of the ACM on Web Conference 2024. 4479–4488

    2024

  25. [33]

    Sebastian Ruder. 2016. An overview of gradient descent optimization algorithms. arXiv preprint arXiv:1609.04747(2016)

    2016 arXiv

  26. [34]

    Shuanghong Shen, Qi Liu, Enhong Chen, Zhenya Huang, Wei Huang, Yu Yin, Yu Su, and Shijin Wang. 2021. Learning Process-consistent Knowledge Tracing. In KDD ’21: The 27th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, Virtual Event, Singapore, August 14-18, 2021, ...

    2021

  27. [35]

    Shuanghong Shen, Qi Liu, Zhenya Huang, Yonghe Zheng, Minghao Yin, Minjuan Wang, and Enhong Chen. 2024. A survey of knowledge tracing: Models, variants, and applications.IEEE Transactions on Learning Technologies(2024)

    2024

  28. [36]

    Ruchir Puri, David S. Kung, Geert Janssen, Wei Zhang, Giacomo Domeniconi, Vladimir Zolotov, Julian Dolby, Jie Chen, Mihir Choudhury, Lindsey Decker, Veronika Thost, Luca Buratti, Saurabh Pujar, Shyam Ramji, Ulrich Finkler, Susan Malaika, and Frederick Reiss. 2021. CodeNet: A L...

    2021 arXiv

  29. [37]

    Fei Wang, Weibo Gao, Qi Liu, Jiatong Li, Guanhao Zhao, Zheng Zhang, Zhenya Huang, Mengxiao Zhu, Shijin Wang, Wei Tong, et al. 2024. A survey of models for cognitive diagnosis: New developments and future directions.arXiv preprint arXiv:2407.05458(2024)

    2024 arXiv

  30. [38]

    Fei Wang, Qi Liu, Enhong Chen, Zhenya Huang, Yu Yin, Shijin Wang, and Yu Su

  31. [39]

    Lisa Wang, Angela Sy, Larry Liu, and Chris Piech. 2017. Deep knowledge tracing on programming exercises. InProceedings of the fourth (2017) ACM conference on learning@ scale. 201–204

    2017

  32. [40]

    Yang Shi, Min Chi, Tiffany Barnes, and Thomas Price. 2022. Code-DKT: A Code-based Knowledge Tracing Model for Programming Tasks.arXiv preprint arXiv:2206.03545(2022)

    2022 arXiv

  33. [41]

    Bogdan M Wilamowski and Hao Yu. 2010. Improved computation for Levenberg– Marquardt training.IEEE transactions on neural networks21, 6 (2010), 930–937

    2010

  34. [42]

    Yaqiang Wu, Hui Zhu, Chenyang Wang, Fujian Song, Haiping Zhu, Yan Chen, Qinghua Zheng, and Feng Tian. 2024. Programming Knowledge Tracing Based on Heterogeneous Graph Representation.Knowledge-Based Systems(2024), 112161

    2024

  35. [43]

    NeuralCD: a general framework for cognitive diagnosis.IEEE Transactions on Knowledge and Data Engineering35, 8 (2022), 8312–8327

    2022

  36. [44]

    Feng Xia, Ke Sun, Shuo Yu, Abdul Aziz, Liangtian Wan, Shirui Pan, and Huan Liu. 2021. Graph learning: A survey.IEEE Transactions on Artificial Intelligence2, 2 (2021), 109–127

    2021

  37. [45]

    Xiao Wang, Meiqi Zhu, Deyu Bo, Peng Cui, Chuan Shi, and Jian Pei. 2020. Am- gcn: Adaptive multi-channel graph convolutional networks. InProceedings of the 26th ACM SIGKDD International conference on knowledge discovery & data mining. 1243–1253

    2020

  38. [46]

    Fangzhou Yao, Qi Liu, Linan Yue, Weibo Gao, Jiatong Li, Xin Li, and Yuanjing He. 2024. Adard: An adaptive response denoising framework for robust learner modeling. InProceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining. 3886–3895

    2024

  39. [47]

    Yu Yin, Le Dai, Zhenya Huang, Shuanghong Shen, Fei Wang, Qi Liu, Enhong Chen, and Xin Li. 2023. Tracing Knowledge Instead of Patterns: Stable Knowledge Tracing with Diagnostic Transformer. InProceedings of the ACM Web Conference

    2023

  40. [48]

    Zhengyang Wu, Ming Li, Yong Tang, and Qingyu Liang. 2020. Exercise recom- mendation based on knowledge concept prediction.Knowledge-Based Systems 210 (2020), 106481

    2020

  41. [49]

    Linan Yue, Qi Liu, Ye Liu, Weibo Gao, Fangzhou Yao, and Wenfeng Li. 2024. Coop- erative classification and rationalization for graph generalization. InProceedings of the ACM on Web Conference 2024. 344–352

    2024

  42. [50]

    Rui Xu and Donald Wunsch. 2005. Survey of clustering algorithms.IEEE Trans- actions on neural networks16, 3 (2005), 645–678

    2005

  43. [51]

    Chuang Zhao, Hongke Zhao, Xiaomeng Li, Ming He, Jiahui Wang, and Jianping Fan. 2023. Cross-domain recommendation via progressive structural alignment. IEEE Transactions on Knowledge and Data Engineering(2023)

    2023

  44. [52]

    Hao Zhao, Ming Lu, Anbang Yao, Yiwen Guo, Yurong Chen, and Li Zhang

  45. [53]

    Man Zhou, Jie Xiao, Yifan Chang, Xueyang Fu, Aiping Liu, Jinshan Pan, and Zheng-Jun Zha. 2021. Image de-raining via continual learning. InProceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 4907–4916

    2021

  46. [54]

    Yang Yu, Yingbo Zhou, Yaokang Zhu, Yutong Ye, Liangyu Chen, and Mingsong Chen. 2024. ECKT: Enhancing Code Knowledge Tracing via Large Language Models. InProceedings of the Annual Meeting of the Cognitive Science Society, Vol. 46

    2024

  47. [55]

    IS Zinovieva, VO Artemchuk, Anna V Iatsyshyn, OO Popov, VO Kovach, Andrii V Iatsyshyn, YO Romanenko, and OV Radchenko. 2021. The use of online coding platforms as additional distance tools in programming education. InJournal of physics: Conference series, Vol. 1840. IOP Publis...

    2021

  48. [56]

    Zheng Zhang, Le Wu, Qi Liu, Jiayu Liu, Zhenya Huang, Yu Yin, Yan Zhuang, Weibo Gao, and Enhong Chen. 2024. Understanding and improving fairness in cognitive diagnosis.Science China Information Sciences67, 5 (2024), 152106

    2024

  49. [61]

    Renyu Zhu, Dongxiang Zhang, Chengcheng Han, Ming Gaol, Xuesong Lu, Wein- ing Qian, and Aoying Zhou. 2022. Programming knowledge tracing: A compre- hensive dataset and a new model. In2022 IEEE International Conference on Data Mining Workshops (ICDMW). IEEE, 298–307

    2022

  50. [2017]

    InProceedings of the IEEE conference on computer vision and pattern recognition

    Physics inspired optimization on semantic transfer features: An alternative method for room layout estimation. InProceedings of the IEEE conference on computer vision and pattern recognition. 10–18

  51. [2019]

    IEEE Transactions on Knowledge and Data Engineering33, 1 (2019), 100–115

    Ekt: Exercise-aware knowledge tracing for student performance prediction. IEEE Transactions on Knowledge and Data Engineering33, 1 (2019), 100–115

    2019

  52. [2022]

    InProceedings of the 45th International ACM SIGIR Conference on Research and Development in Information Retrieval

    PST: Measuring Skill Proficiency in Programming Exercise Process via Programming Skill Tracing. InProceedings of the 45th International ACM SIGIR Conference on Research and Development in Information Retrieval. 2601–2606

  53. [2023]

    Denoising Programming Knowledge Tracing with a Code Graph-based Tuning Adaptor KDD ’25, August 3–7, 2025, Toronto, ON, Canada

    855–864. Denoising Programming Knowledge Tracing with a Code Graph-based Tuning Adaptor KDD ’25, August 3–7, 2025, Toronto, ON, Canada

    2025

  54. [2025]

    Foundation model enhanced derivative-free cognitive diagnosis.Frontiers of Computer Science19, 1 (2025), 191318

    2025

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.