Improving Deep Knowledge Tracing via Gated Architectures and Adaptive Optimization

Altun Shukurlu

REVIEW 4 major objections 5 minor 23 references

Improving Deep Knowledge Tracing via Gated Architectures and Adaptive Optimization

T0 review · 4 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read This paper argues that swapping vanilla RNNs for gated cells and adaptive optimizers makes Deep Knowledge Tracing more accurate, stable, and reproducible.

desk verdict Clean PyTorch DKT reimplementation, but the abstract sells results the tables don't contain. read the letter →

arxiv 2504.20070 v1 pith:YU5B5DAU submitted 2025-04-24 cs.LG

Altun Shukurlu This is my paper · ORCID

classification cs.LG

keywords deepknowledgetracingstudentperformancepredictiongatedrecurrentnetworkslongshort-termmemoryunitsadaptiveoptimizationconvergencespeededucationaldatasets

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

This paper sets out to modernise Deep Knowledge Tracing (DKT), the recurrent-network baseline that predicts whether a student will answer the next exercise correctly. It argues that replacing the original vanilla recurrent unit with gated cells, either long short-term memory (LSTM) or gated recurrent units (GRU), improves accuracy and training stability, and that adaptive optimizers such as Adam and AdamW converge faster and achieve better accuracy than plain stochastic gradient descent. The experiments use the standard Synthetic-5 and Khan Academy datasets with a modular open-source implementation that replaces the original deprecated codebase. If the claim holds, the default recipe for a DKT baseline becomes LSTM or GRU plus an adaptive optimizer, which matters because DKT is a common starting point for personalised-learning systems.

What carries the argument

The load-bearing mechanism is the gated recurrent cell: LSTM's forget, input, and output gates, and GRU's update and reset gates, control how much of the previous hidden state and current input contribute to the next state, letting training gradients propagate over longer interaction sequences instead of vanishing. The second mechanism is adaptive per-parameter learning: Adam and AdamW keep exponential moving averages of past gradients and squared gradients, and AdamW pairs this with decoupled weight decay, so each parameter gets its own step size early in training. Together these two mechanisms carry the paper's argument that the model captures long-term student knowledge while the optimizer quickly finds a useful parameter region.

What would settle it

Train the same LSTM and GRU DKT models on Synthetic-5 and the Khan Academy subset for, say, 50 epochs with SGD and AdamW, and report final test AUC and accuracy; if the adaptive optimizers' edge over SGD disappears or reverses at convergence, the paper's final-performance claim is refuted.

Watch

Extended reading notes

Core claim

The central claim is that both weaknesses of the original DKT pipeline, un-gated recurrence and an outdated training setup, are fixable with standard components. On the architecture side, the paper reports that LSTM and GRU models reach the same test accuracy (0.6356 on Synthetic-5 in its Table 1) while being more stable than basic RNNs, with LSTM slightly better on training loss and GRU faster per epoch. On the optimisation side, a one-epoch comparison on Khan Academy (Table 2) shows all adaptive optimizers above 53% accuracy while SGD reaches only 45%, with AdamW best at 55.50%; the paper takes this as evidence that adaptive methods are better for both early-stage learning and final performance. The discovery is an empirical modernisation result, not a new architecture: the gains come from standard gated cells and standard adaptive optimizers.

Load-bearing premise

The paper treats accuracy after the first training epoch as evidence for both early-stage learning and final model quality; if one-epoch accuracy does not predict converged performance, the conclusion about final model performance is not established.

Editorial extensions

If this is right

A DKT baseline can be assembled from standard gated cells and an adaptive optimizer without custom machinery, and should reach better early results than the original RNN-plus-SGD recipe.
AdamW is the recommended default when per-epoch compute matters, because it gives the highest first-epoch accuracy with training time comparable to SGD.
GRU offers nearly the same accuracy as LSTM at lower per-epoch cost, making it a fit for resource-limited tutoring systems.
The modular open-source implementation gives a reproducible foundation, so later knowledge-tracing research can compare new models against a maintained baseline.

Reading between the lines

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

A natural extension is to train all five optimizers to convergence rather than one epoch; if the early ordering persists, the practical recommendation to reach for AdamW first becomes much stronger.
The same one-epoch dominance of adaptive optimizers would probably appear in other sequence-prediction tasks, because per-parameter learning rates drive early gradient descent regardless of dataset; that extrapolation is testable.
An explicit vanilla-RNN baseline re-run in the same codebase would quantify how much of the improvement comes from gating versus the new implementation and optimizer, since the paper compares against the original reported results rather than a new RNN run.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

Short version: this paper is a PyTorch port of the DKT baseline with an LSTM/GRU swap and an optimizer scan. The abstract claims gated architectures beat basic RNNs and that Adam/AdamW beat SGD in both early and final performance. The tables don't back up either claim.

What's good: the code is public, the implementation looks clean, and the authors are right that the original Torch pipeline is hard to reuse. For someone wanting a minimal modern DKT starting point, this could save time. The LSTM/GRU equations and optimizer descriptions are standard and accurate. Citations are mostly fine.

Where it falls short: Table 1 gives identical train and test accuracy for LSTM and GRU (0.6344/0.6356), contradicting the text's claim that LSTM outperforms GRU. More importantly, there is no RNN baseline anywhere, so the headline claim about GRU/LSTM beating basic RNNs is asserted, not demonstrated. The optimizer table (Table 2) is limited to one epoch and doesn't state whether the accuracy is train or test; the stress-test note is correct that one-epoch accuracy says nothing about converged final performance. The abstract's 'final model performance' is unsupported. There are also no error bars, learning curves, learning-rate schedules, or repeated seeds. To the author's credit, Section 4.2.1 explicitly says the optimizer comparison is after one epoch, but the abstract still overreaches.

Who gets value: a practitioner wanting a clean PyTorch DKT baseline and willing to verify the optimizer claims themselves. As a research contribution, the evidence is too thin. However, with a reproduced RNN baseline, full training curves, test accuracy at convergence, and variance estimates, this could become a useful reproducibility study. That revision is substantial but doable, so I'd take it for peer review with that expectation.

Recommendation: if this lands on your desk, accept the review assignment but ask for major revision: add the RNN baseline, run optimizers to convergence, report test accuracy with standard deviations, and soften the abstract to match the measured results.

Referee Report

4 major / 5 minor

Summary. The paper revisits Deep Knowledge Tracing (DKT) by re-implementing the model in PyTorch with LSTM and GRU backbones and by benchmarking several optimizers (SGD, RMSProp, Adagrad, Adam, AdamW). The abstract claims that gated architectures improve accuracy and training stability over basic RNNs and that adaptive optimizers outperform SGD in both early-stage learning and final model performance. Experiments are reported on the Synthetic-5 dataset (architecture comparison) and the Khan Academy dataset (optimizer comparison). The paper also makes available two GitHub repositories containing the code.

Significance. If the claims were well supported, the paper would offer a useful practical baseline for knowledge tracing practitioners: a modular PyTorch DKT implementation with LSTM/GRU and AdamW would be a sensible default. The exposition of the RNN/LSTM/GRU equations is clear, and the per-epoch training-time table provides some useful cost information. However, the significance is severely weakened by the mismatch between the claims and the evidence: no standard RNN baseline is reported, the LSTM-vs-GRU comparison shows identical accuracy, and the optimizer conclusion rests entirely on a single training epoch. The paper's contribution is therefore better characterized as a preliminary reproducibility report than as an established empirical result.

major comments (4)

[Section 4.2.1, Table 2] Table 2 reports only error and accuracy after the first training epoch, and no test-set accuracy, learning curves, final checkpoints, or repeated-seed variance are provided anywhere in the optimizer analysis. The abstract and conclusion claim that adaptive optimizers 'consistently outperform SGD in both early-stage learning and final model performance,' but final model performance is never measured. One-epoch accuracy is not a valid proxy for converged performance, so the final-performance half of the central claim is unsupported. Please either add converged experimental results with test metrics or remove the final-performance wording from the abstract and conclusion.
[Section 4.1, Table 1] The text states that 'the LSTM model outperformed it [the GRU model] in terms of both stability and predictive accuracy,' but Table 1 reports identical Train Accuracy (0.6344) and Test Accuracy (0.6356) for LSTM and GRU, with LSTM having a higher training loss. The table does not support the claim of LSTM superiority. In addition, no standard RNN baseline is reported anywhere in the paper, so the central claim that 'GRUs and LSTMs achieve higher accuracy and improved training stability compared to basic RNNs' is not evidenced. Please add an RNN baseline experiment or explicitly restrict the claims to what the reported experiments support.
[Sections 3 and 4.2.1] Section 3 says the optimizers are evaluated on 'convergence speed and final predictive performance,' but the only quantitative evidence is a single epoch. The title of Section 4.2.1 ('Convergence Performance After 1 Epoch') is also misleading, since one step of training does not measure convergence. If the manuscript's practical recommendation depends on convergence and final accuracy, the experiments must be continued to a defined stopping criterion with test-set evaluation; otherwise the recommendation should be limited to early-stage behavior.
[Section 4 (experimental setup)] No hyperparameters are reported: learning rate, hidden size, number of layers, batch size, number of training epochs, learning-rate schedule, and dataset splits are all absent. Because a stated contribution is reproducibility, these details are load-bearing, not cosmetic. Without them, the open-source code cannot be used as a reproducible baseline, and the numeric results cannot be interpreted or compared with prior DKT work.

minor comments (5)

[Section 2.1 heading] The heading 'Deep Knowledge T racing' contains a stray space and should read 'Deep Knowledge Tracing'.
[Section 2.1] There are missing spaces in phrases such as 'such asBayesian Knowledge Tracing' and 'andPerformance Factor Analysis'.
[References] Reference [8] appears to be a non-existent JMLR paper: 'Edward Yang, Antonio S. Rojas, Justin Z. Zhang, and David B. Knowles. Pytorch: High-performance computation and machine learning.' Please verify and correct, since it is a very major citation for the paper's framework claim.
[References] Reference [22] (Elman 1990) is cited to support the claim that 'LSTMs have become a widely adopted backbone architecture'; Elman's paper introduces a simple recurrent network, not an LSTM, so this citation is misleading.
[Section 2.3] The paper benchmarks AdamW but never describes its decoupled weight decay rule; the optimizer listing ends with Adam. Please add the AdamW update equations or at least a sentence explaining how it differs from Adam.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity found: the paper is an empirical benchmark with no derivation chain that reduces to its inputs.

full rationale

This manuscript makes no formal derivation claim; its results are reported measurements from the author's own PyTorch implementation on Synthetic-5 and Khan Academy data. There is no fitted parameter renamed as a prediction, no normalization or rescaling identity that makes an output equal to an input by construction, and no invocation of a uniqueness theorem from prior work by the same author. The architectural comparison (LSTM vs GRU, Table 1) and optimizer comparison (Table 2) are empirical observations, not consequences of definitions. The optimizer update equations in Section 3 are standard textbook definitions and are not used to derive the benchmark outcomes. The abstract's assertion that adaptive optimizers 'consistently outperform SGD in both early-stage learning and final model performance' is not circular, but it is only partially supported by the evidence: Section 4.2.1 explicitly says 'we focus on performance metrics from the first epoch' and reports only one-epoch accuracy, so the 'final model performance' portion is an unsupported generalization rather than a circular one. The identical test accuracy values for LSTM and GRU in Table 1 are suspicious and merit scrutiny, but they do not constitute a self-referential reduction. Accordingly, the appropriate circularity score is 0.

Assumptions & free parameters 3 free parameters · 3 assumptions · 0 invented entities

The paper introduces no new entities or theoretical constructs. Its empirical results depend on unstated hyperparameters and on the assumption that a single training epoch is informative about final model quality.

free parameters (3)

Learning rate = not reported
No learning rate or schedule is given for any optimizer; all comparisons depend on these values.
Hidden size, layers, batch size = not reported
These architecture choices directly affect accuracy and timing, and they are absent from the paper.
Number of training epochs = not reported
The LSTM vs GRU comparison reports training time but not how many epochs were run, so 'test accuracy' cannot be interpreted as a stable final result.

assumptions (3)

ad hoc to paper One epoch of training is a valid proxy for convergence and final model performance.
Section 4.2.1 limits the optimizer comparison to the first epoch and the abstract generalizes to final model performance.
domain assumption The Synthetic-5 and Khan Academy datasets are correctly preprocessed and the splits are representative.
No preprocessing, split, or dataset version details are provided; these are standard assumptions for empirical ML papers.
domain assumption The original DKT implementation with a basic RNN performs as described in the original paper.
No RNN baseline is reproduced, so the claimed improvement over the original RNN is taken on trust from the literature.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Improving Deep Knowledge Tracing via Gated Architectures and Adaptive Optimization." pith.science (2026). https://pith.science/paper/YU5B5DAU

@misc{pith2026250420070,
  author       = {Pith},
  title        = {Pith review of: Improving Deep Knowledge Tracing via Gated Architectures and Adaptive Optimization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/YU5B5DAU}},
  note         = {Machine review of arXiv:2504.20070}
}

read the original abstract

Deep Knowledge Tracing (DKT) models student learning behavior by using Recurrent Neural Networks (RNNs) to predict future performance based on historical interaction data. However, the original implementation relied on standard RNNs in the Lua-based Torch framework, which limited extensibility and reproducibility. In this work, we revisit the DKT model from two perspectives: architectural improvements and optimization efficiency. First, we enhance the model using gated recurrent units, specifically Long Short-Term Memory (LSTM) networks and Gated Recurrent Units (GRU), which better capture long-term dependencies and help mitigate vanishing gradient issues. Second, we re-implement DKT using the PyTorch framework, enabling a modular and accessible infrastructure compatible with modern deep learning workflows. We also benchmark several optimization algorithms SGD, RMSProp, Adagrad, Adam, and AdamW to evaluate their impact on convergence speed and predictive accuracy in educational modeling tasks. Experiments on the Synthetic-5 and Khan Academy datasets show that GRUs and LSTMs achieve higher accuracy and improved training stability compared to basic RNNs, while adaptive optimizers such as Adam and AdamW consistently outperform SGD in both early-stage learning and final model performance. Our open-source PyTorch implementation provides a reproducible and extensible foundation for future research in neural knowledge tracing and personalized learning systems.

Figures

Figures reproduced from arXiv: 2504.20070 by the authors.

**Figure 2.** Gating Mechanisms in LSTM architecture ft = σ(Wfxt + Ufht−1 + bf ) it = σ(Wixt + Uiht−1 + bi) ot = σ(Woxt + Uoht−1 + bo) c˜t = tanh(Wcxt + Ucht−1 + bc) ct = ft ⊙ ct−1 + it ⊙ c˜t ht = ot ⊙ tanh(ct) where ft is the forget gate, controlling the amount of previous memory to forget, it is the input gate, determining how much of the current input is used to update the memory and C˜ t represents the candidate memory cell, … view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

23 extracted references · 14 canonical work pages

[1]

Deep knowledge tracing

Chris Piech, Jonathan Bassen, Jonathan Huang, Surya Ganguli, Mehran Sahami, Leonidas Guibas, and Jascha Sohl-Dickstein. Deep knowledge tracing. InAdvances in Neural Information Processing Systems, volume 28, pages 505–513, 2015

work page 2015
[2]

Long short-term memory.Neural Computation, 9 (8):1735–1780, 1997

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

1997
[3]

Learning phrase representations using rnn encoder–decoder for statistical machine translation.arXiv preprint arXiv:1406.1078, 2014

Kyunghyun Cho, Bart van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder–decoder for statistical machine translation.arXiv preprint arXiv:1406.1078, 2014

arXiv 2014
[4]

Learning long-term dependencies with gradient descent is difficult

Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. In IEEE Transactions on Neural Networks, volume 5, pages 157–166, 1994

work page 1994
[5]

Speech recognition with deep recurrent neural networks

Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In2013 IEEE international conference on acoustics, speech and signal processing, pages 6645–6649. Ieee, 2013

2013
[6]

Pytorch: An imperative style, high-performance deep learning library

Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. InAdvances in Neural Information Processing Systems, volume 32, pages 8026–8037, 2019

work page 2019
[7]

Deep Forward and Inverse Perceptual Models for Tracking and Prediction

Adam Paszke, Sam Gross, and Soumith Chintala. Automatic differentiation in pytorch. In Proceedings of NeurIPS, 2017. URL https://arxiv.org/abs/1710.11311

work page Pith review arXiv 2017
[8]

Almost ordinary abelian varieties over finite fields

Edward Yang, Antonio S. Rojas, Justin Z. Zhang, and David B. Knowles. Pytorch: High- performance computation and machine learning.Journal of Machine Learning Research, 20 (100):1–23, 2019. URL https://arxiv.org/abs/1901.01589

work page Pith review arXiv 2019

Show all 23 references

[9]

A stochastic approximation method.The Annals of Mathematical Statistics, 22(3):400–407, 1951

Herbert Robbins and Sutton Monro. A stochastic approximation method.The Annals of Mathematical Statistics, 22(3):400–407, 1951. 10

1951
[10]

Lecture 6.5 - rmsprop: Divide the gradient by a running average of its recent magnitude

Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5 - rmsprop: Divide the gradient by a running average of its recent magnitude. Coursera: Neural Networks for Machine Learning, 2012. URL https://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf

2012
[11]

Adaptive subgradient methods for online learning and stochastic optimization.Journal of Machine Learning Research, 12:2121–2159, 2011

John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization.Journal of Machine Learning Research, 12:2121–2159, 2011

2011
[12]

Adam: A method for stochastic optimization.arXiv preprint arXiv:1412.6980, 2014

Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization.arXiv preprint arXiv:1412.6980, 2014. URL https://arxiv.org/abs/1412.6980

2014 arXiv
[13]

Decoupled weight decay regularization

Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. InInternational Conference on Learning Representations (ICLR), 2019

2019
[14]

Corbett and John R

Albert T. Corbett and John R. Anderson. Knowledge tracing: Modeling the acquisition of procedural knowledge. User Modeling and User-Adapted Interaction, 4(4):253–278, 1994

1994
[15]

Koedinger

Philip I Pavlik Jr, Hao Cen, and Kenneth R. Koedinger. Performance factors analysis–a new alternative to knowledge tracing. InProceedings of the 14th International Conference on Artificial Intelligence in Education, pages 531–538, 2009

2009
[16]

Self-attentive knowledge tracing

Srijan Kumar Pandey and George Karypis. Self-attentive knowledge tracing. InProceedings of the 12th International Conference on Educational Data Mining (EDM), 2019

2019
[17]

Context-aware attentive knowledge tracing

Arghya Ghosh and Neil Heffernan. Context-aware attentive knowledge tracing. InProceedings of the 13th International Conference on Educational Data Mining (EDM), 2020

2020
[18]

Dynamic key-value memory networks for knowledge tracing

Jian Zhang, Xingjian Shi, Irwin King, and Dit-Yan Yeung. Dynamic key-value memory networks for knowledge tracing. InProceedings of the 26th International Conference on World Wide Web, pages 765–774, 2017

2017
[19]

Graph-based knowledge tracing: Modeling student learning with concepts and relations

Hiroki Nakagawa, Yusuke Iwasawa, and Yutaka Matsuo. Graph-based knowledge tracing: Modeling student learning with concepts and relations. InProceedings of the 9th International Conference on Learning Analytics & Knowledge, pages 330–339, 2019

2019
[20]

Knowledge tracing: A survey.ACM Computing Surveys, 55(11):224:1–224:37, 2023

Ghodai Abdelrahman, Qing Wang, and Bernardo Nunes. Knowledge tracing: A survey.ACM Computing Surveys, 55(11):224:1–224:37, 2023. doi: 10.1145/3569576

2023 doi
[21]

A survey of knowledge tracing

Qi Liu, Shuanghong Shen, Zhenya Huang, Enhong Chen, and Yonghe Zheng. A survey of knowledge tracing. arXiv preprint arXiv:2105.15106, 2021. URL https://arxiv.org/abs/ 2105.15106

2021 arXiv
[22]

Jeffrey L. Elman. Finding structure in time.Cognitive Science, 14(2):179–211, 1990

1990
[23]

Training Recurrent Neural Networks

Ilya Sutskever. Training Recurrent Neural Networks. Phd thesis, University of Toronto, Toronto, Canada, 2013. URLhttps://www.cs.toronto.edu/~ilya/pubs/ilya_sutskever_ phd_thesis.pdf. 11

2013

Pith tools

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

[1] [1]

Deep knowledge tracing

Chris Piech, Jonathan Bassen, Jonathan Huang, Surya Ganguli, Mehran Sahami, Leonidas Guibas, and Jascha Sohl-Dickstein. Deep knowledge tracing. InAdvances in Neural Information Processing Systems, volume 28, pages 505–513, 2015

work page 2015

[2] [2]

Long short-term memory.Neural Computation, 9 (8):1735–1780, 1997

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

1997

[3] [3]

Learning phrase representations using rnn encoder–decoder for statistical machine translation.arXiv preprint arXiv:1406.1078, 2014

Kyunghyun Cho, Bart van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder–decoder for statistical machine translation.arXiv preprint arXiv:1406.1078, 2014

arXiv 2014

[4] [4]

Learning long-term dependencies with gradient descent is difficult

Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. In IEEE Transactions on Neural Networks, volume 5, pages 157–166, 1994

work page 1994

[5] [5]

Speech recognition with deep recurrent neural networks

Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In2013 IEEE international conference on acoustics, speech and signal processing, pages 6645–6649. Ieee, 2013

2013

[6] [6]

Pytorch: An imperative style, high-performance deep learning library

Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. InAdvances in Neural Information Processing Systems, volume 32, pages 8026–8037, 2019

work page 2019

[7] [7]

Deep Forward and Inverse Perceptual Models for Tracking and Prediction

Adam Paszke, Sam Gross, and Soumith Chintala. Automatic differentiation in pytorch. In Proceedings of NeurIPS, 2017. URL https://arxiv.org/abs/1710.11311

work page Pith review arXiv 2017

[8] [8]

Almost ordinary abelian varieties over finite fields

Edward Yang, Antonio S. Rojas, Justin Z. Zhang, and David B. Knowles. Pytorch: High- performance computation and machine learning.Journal of Machine Learning Research, 20 (100):1–23, 2019. URL https://arxiv.org/abs/1901.01589

work page Pith review arXiv 2019