Pith. sign in

REVIEW 3 major objections 5 minor 25 references

Automatic Compiler Based FPGA Accelerator for CNN Training

T0 review · 3 major / 5 minor · reviewed 2026-08-14 · deepseek-v4-flash

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

Pith's one-line read The paper claims that CNN training can be fully automated onto FPGAs by an RTL compiler, reaching up to 479 GOPS and 73% CIFAR-10 accuracy for its smallest network.

desk verdict A plausible compiler-based FPGA training flow with a genuinely useful transposable weight buffer, but the headline accuracy and throughput numbers come from simulation and emulation, not from a demonstrated FPGA training run. read the letter →

arxiv 1908.06724 v1 pith:QV55I6IM submitted 2019-08-15 cs.LG cs.NEeess.SP

Shreyas Kolala Venkataramanaiah , Yufei Ma , Shihui Yin , Eriko Nurvithadhi , Aravind Dasu , Yu Cao , Jae-sun Seo This is my paper · ORCID
classification cs.LGcs.NEeess.SP
keywords CNNtrainingFPGAacceleratorRTLcompilerbackpropagationweightupdatefixed-pointarithmetictransposablebufferCIFAR-10
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 tries to establish that CNN training — forward pass, backward pass, and weight update — can be mapped entirely to FPGA hardware by an automatic RTL compiler, with no CPU performing the training math. The user supplies a high-level network description and FPGA constraints, and the compiler assembles parameterized Verilog modules into a synthesizable accelerator that uses 16-bit fixed-point arithmetic throughout. If the claim holds, it would let small networks be retrained on embedded devices while keeping the flexibility to change network structure by recompiling. The paper reports up to 479 GOPS on a Stratix 10 GX FPGA and 73% CIFAR-10 accuracy for its smallest network, which is the concrete payoff of the approach.

What carries the argument

The load-bearing mechanism is the transposable weight buffer: kernels are laid out as a circulant matrix of column buffers, and an address translator shifts the per-column read addresses so the same stored data can be read normally, rotated by 180 degrees, or transposed without a second copy. Around this sit the RTL compiler, which selects and parameterizes modules from a training-specific library, and the 2D systolic MAC array, which is reused across forward pass, backward pass, and weight update by changing which data streams are routed to it. A dedicated weight-update unit accumulates gradients tile-by-tile over a batch and applies SGD with momentum, and a MAC load-balancing unit packs multiple kernel-gradient computations into otherwise idle MAC columns.

What would settle it

Synthesize and program the generated RTL on the same Stratix 10 GX device, run the three CIFAR-10 training configurations end to end, and compare measured epoch latency, power, and final accuracy with the reported 163/282/479 GOPS and 73% figures; if the fixed-point software model's accuracy is not reproduced by the actual training run, or if simulated latency is far from measured latency, the central claim fails.

Watch

Extended reading notes

Core claim

The paper's central claim is that one reconfigurable MAC array, fed by a small set of training-specific modules, can execute all three phases of SGD training through compiler-generated control logic. During forward pass the MAC array convolves activations with normal kernels; during backward pass the same array convolves local gradients with rotated kernels; during weight update it convolves activations with local gradients to produce kernel gradients. The paper's new storage scheme, a transposable weight buffer organized as a circulant matrix, lets these rotated and transposed reads happen from a single copy of the weights. On three CIFAR-10 networks of increasing width, the generated accelerators sustain 163, 282, and 479 GOPS at 240 MHz, with the smallest network reaching 73% accuracy after 50 epochs, similar to its floating-point baseline.

Load-bearing premise

The central claim holds only if the simulated accelerator's latency, power, and the fixed-point software model's accuracy match what the FPGA would actually do when programmed.

Editorial extensions

If this is right

  • Training can be re-targeted to a new CNN configuration by recompiling from the high-level description, so network changes do not require hand-written RTL.
  • The same accelerator executes FP, BP, and WU with one MAC array, so on-chip resources are shared across training phases rather than tripled.
  • Small-batch training, which the paper argues is more stable, is energy-competitive on FPGA because images are processed sequentially and the accelerator's throughput does not depend on batch size.
  • At batch sizes 1 and 40 the FPGA is more energy-efficient than the GPU for the 1X and 2X networks, while the 4X network at batch 40 falls behind because of DRAM bandwidth.

Reading between the lines

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

  • The transposable buffer idea should transfer to any workload that reads a weight matrix in both normal and transposed forms, including attention layers and other matrix-multiplication-heavy training, though the paper does not demonstrate this.
  • The compiler's module library is the long-term asset: as more layers such as batch normalization or other loss functions are added, the same compiler flow could absorb them, keeping the automation story intact.
  • A direct test the paper leaves open is an on-chip training run; if measured accuracy and throughput reproduce the simulation-based numbers, the compiler approach becomes a credible blueprint for on-device learning.
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.

Referee Report

3 major / 5 minor

Summary. The paper describes an automatic RTL compiler that generates FPGA-synthesizable accelerators for complete CNN training, including forward pass, backward pass, and weight update, using 16-bit fixed-point arithmetic. The accelerator is built from a parameterized Verilog module library and includes a transposable weight buffer for non-transpose/transpose reads, a systolic MAC array reused across FP/BP/WU, and a MAC load-balancing unit for weight-gradient convolutions. The authors report synthesized results on an Intel Stratix 10 GX FPGA for three CIFAR-10 CNNs, with reported throughput up to 479 GOPS and 73% CIFAR-10 accuracy for the 1X network.

Significance. If the reported results were fully validated on hardware, the work would be a useful step toward compiler-based on-device CNN training accelerators, with a concrete RTL library, a cyclic weight storage scheme, and clear reuse of the MAC array across training phases. The paper is also careful to describe architectural mechanisms such as the transposable buffer and load-balancing unit. However, the central evidence is not hardware measurement: the paper explicitly states that latency was measured by simulation, power was estimated by tools, and functionality was verified with a custom fixed-point PyTorch model. The stress-test concern raised by the reader is therefore grounded in the manuscript: the end-to-end training claim and the 479 GOPS figure currently rest on an unverified equivalence between the PyTorch emulation and the synthesized RTL. Because no artifact or verification data is provided, the contribution, while plausible, is not yet demonstrated at the level claimed in the abstract.

major comments (3)
  1. [Abstract and Section IV.A] The abstract states that the CNNs were 'implemented and trained on Intel Stratix 10-GX FPGA', but Section IV.A says that latency was measured using simulation of the synthesized accelerator, power was obtained from Quartus power analyzer and Intel Early Power Estimator using toggling activity from functional simulation, and a custom fixed-point PyTorch model was used 'to verify the functionality of the FPGA design'. No section reports an actual training run on the FPGA device. This is a load-bearing gap because the headline claims of complete CNN training and 479 GOPS are performance/functionality claims about hardware. Please either provide on-board measurement results or revise the abstract and conclusions to state explicitly that the results are from simulation of the synthesized accelerator rather than from on-FPGA training.
  2. [Section IV.A and Section IV.B] The 73% CIFAR-10 accuracy is not tied to the RTL design. The text says the fixed-point PyTorch model was used to verify the FPGA design, but no comparison is reported between the PyTorch emulation and the RTL simulation on identical inputs, initial weights, hyperparameters, and training schedule. For 16-bit fixed-point arithmetic, the result depends on accumulation order and rounding modes, and a systolic MAC array with a specific on-chip reduction order can differ from a PyTorch emulation that merely uses the same word width. Please provide bit-exact or explicitly tolerance-bounded equivalence checks for at least one full FP/BP/WU iteration, and report the accuracy obtained from the RTL simulation or from hardware, not only from the PyTorch model.
  3. [Table II and Table III] Table II is labeled 'Evaluation of CNN training accelerator on Stratix 10 FPGA', and Table III compares FPGA throughput and efficiency with a Titan XP GPU, but the FPGA numbers are simulation-based while the GPU numbers are presumably measured. This makes the comparison misleading unless the simulation methodology is stated in the table captions and the GOPS definition is clarified (e.g., whether a MAC operation counts as one or two operations). Because the reported 479 GOPS is derived from simulated latency, the performance claim should be labeled as simulated throughput, not demonstrated hardware throughput.
minor comments (5)
  1. [Section IV.A] Section IV.A reports that the Stratix 10 GX device has 93K ALMs, but Table II lists ALM utilizations of 19%, 44%, and 76.2% for the 1X, 2X, and 4X designs, respectively. These percentages are inconsistent with a 93K ALM total (the implied total would be roughly 940K ALMs). Please correct the device specification or the table entries.
  2. [Table III] The header of Table III, 'Batch size 1 40 1/40', is ambiguous: it appears to list batch size 1, batch size 40, and then a separate column labeled '1/40' that is likely the ratio of FPGA to GPU efficiency. Please clarify the column meanings directly in the caption.
  3. [Section II] Equation (4) uses the subscript n in 'Delta w_n' for the batch index while the left-hand side uses 'Lx,y' as a spatial index; this dual use of n and the unlabeled axes makes the equation difficult to follow. Please define all indices explicitly.
  4. [Figure 5] The transposable weight buffer is a central contribution, but Figure 5 is hard to parse without a more detailed explanation of the circulant matrix layout and the address translation for transpose reads. A small concrete example with numeric addresses would help.
  5. [Section I] The related work discussion mentions DeepTrain, F-CNN, and TrainWare, but it does not quantitatively position the proposed work against those prior training accelerators in terms of accuracy, throughput, or energy. Adding a comparison table or explicit qualitative comparison would strengthen the novelty claim.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation; compiler/RTL claims rest on simulation and emulation, with only minor non-load-bearing self-citations.

full rationale

The paper's central claims are hardware-construction claims: an RTL compiler maps CNN training descriptions to synthesized Verilog, and the resulting accelerator's throughput and accuracy are evaluated in Section IV. There is no fitted parameter, no predictive model fitted to the outcome, and no uniqueness theorem invoked to select an ansatz. The 479 GOPS figure is a simulated/synthesized property of the generated design, and the 73% CIFAR-10 accuracy is attributed to a custom fixed-point PyTorch model built 'to verify the functionality of the FPGA design with the same precision' (Section IV.A). That attribution is an evidence gap, since the paper does not demonstrate bit-exact RTL-vs-PyTorch equivalence on identical inputs and weight-update order, but it is not circular: the PyTorch emulator is not defined in terms of the FPGA result, and the accuracy claim is not fitted from the target quantity. The only self-citations, references [4] and [14], appear in related-work and motivation contexts and are not used as proof of any result, so they are minor and non-load-bearing. The comparison against Titan XP GPU in Table III is an external benchmark rather than a circular target. Accordingly, no circular step is identified; the score of 2 reflects the rubric's treatment of minor non-load-bearing self-citation rather than any actual circularity.

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

The central performance and accuracy claims rest on assumptions that simulation and a PyTorch emulation stand in for board measurements, and that 16-bit fixed-point arithmetic preserves training accuracy. These assumptions are reasonable for a system paper but are not verified with on-board data or released artifacts, so they are load-bearing.

free parameters (3)
  • Learning rate alpha = 0.002
    Used for all reported training runs and the 73% CIFAR-10 accuracy claim. This is a conventional SGD hyperparameter chosen by hand, not fitted to data, but the accuracy result depends on it.
  • Batch size = up to 40
    The accuracy result uses batch size 40, and the throughput comparison reports batch sizes 1, 20, and 40. This is a standard training hyperparameter, not a fitted constant, but it affects the reported numbers.
  • Loop unroll factors = 8x8x16, 8x8x32, 8x8x64 for 1X, 2X, 4X CNNs
    These user-specified design parameters determine the MAC array size and directly set the reported GOPS. The 479 GOPS headline corresponds to the largest unroll factor on the 4X CNN and cannot be separated from this choice.
assumptions (4)
  • domain assumption 16-bit fixed-point precision is sufficient for convergent CNN training with accuracy comparable to floating point.
    Invoked in Section II when the paper states that 16-bit fixed point is used 'to ensure good training accuracy'. The paper cites references [10] and [22] but does not provide a direct fixed-point versus floating-point accuracy comparison in this work.
  • domain assumption Latency measured from simulation of the synthesized accelerator with DRAM models is representative of real FPGA operation.
    Section IV.A states 'Latency was measured using simulation of the synthesized accelerator.' All throughput and latency numbers in Tables II and III rest on this assumption, and no on-board measurement is reported.
  • domain assumption The custom fixed-point PyTorch model faithfully reproduces the numerical behavior of the RTL hardware.
    Section IV.A says the PyTorch model was developed 'to verify the functionality of the FPGA design with the same precision', but no bit-exact comparison, error analysis, or hardware-in-the-loop verification is shown.
  • standard math Standard backpropagation and SGD with momentum equations, including kernel flipping and max-pooling index propagation, are correct for the supported layers.
    Equations (3) through (6) are standard and unproblematic; they are not derived in the paper but are used as background for the hardware design.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Automatic Compiler Based FPGA Accelerator for CNN Training." pith.science (2026). https://pith.science/paper/QV55I6IM

@misc{pith2026190806724,
  author       = {Pith},
  title        = {Pith review of: Automatic Compiler Based FPGA Accelerator for CNN Training},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/QV55I6IM}},
  note         = {Machine review of arXiv:1908.06724}
}
read the original abstract

Training of convolutional neural networks (CNNs)on embedded platforms to support on-device learning is earning vital importance in recent days. Designing flexible training hard-ware is much more challenging than inference hardware, due to design complexity and large computation/memory requirement. In this work, we present an automatic compiler-based FPGA accelerator with 16-bit fixed-point precision for complete CNNtraining, including Forward Pass (FP), Backward Pass (BP) and Weight Update (WU). We implemented an optimized RTL library to perform training-specific tasks and developed an RTL compiler to automatically generate FPGA-synthesizable RTL based on user-defined constraints. We present a new cyclic weight storage/access scheme for on-chip BRAM and off-chip DRAMto efficiently implement non-transpose and transpose operations during FP and BP phases, respectively. Representative CNNs for CIFAR-10 dataset are implemented and trained on Intel Stratix 10-GX FPGA using proposed hardware architecture, demonstrating up to 479 GOPS performance.

Figures

Figures reproduced from arXiv: 1908.06724 by the authors.

Figure 2
Figure 2. Convolution operations and changes in kernels during [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 1
Figure 1. SGD based CNN training dataflow illustrated for a [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 3
Figure 3. Proposed RTL compiler automatically generates FPGA [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Top-level block diagram of CNN training accelerator. [PITH_FULL_IMAGE:figures/full_fig_p003_4.png]
Figure 5
Figure 5. Figure 5: Proposed transposable weight buffer stores weights in [PITH_FULL_IMAGE:figures/full_fig_p004_5.png]
Figure 7
Figure 7. Figure 7: Block diagram of weight update unit. Weights are initially stored in transposable format in DRAM as aforementioned. The entire transposable weights of layer l are read from DRAM to the old weight buffer. New weights are computed tile-by-tile and written back in transpo…
Figure 10
Figure 10. Figure 10: Buffer usage breakdown of CIFAR-10 4X CNN. [PITH_FULL_IMAGE:figures/full_fig_p006_10.png]
Figure 9
Figure 9. Figure 9: Latency breakdown of CIFAR-10 4X CNN for FP, BP [PITH_FULL_IMAGE:figures/full_fig_p006_9.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

25 extracted references · 24 canonical work pages

  1. [1]

    Squeeze-and-excitation networks,

    J. Hu, L. Shen, and G. Sun, “Squeeze-and-excitation networks,” in Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 7132–7141, 2018

    work page 2018

  2. [2]

    Towards end-to-end speech recognition with deep convolutional neural networks,

    Y . Zhang, M. Pezeshki, P. Brakel, S. Zhang, C. Laurent, Y . Bengio, and A. Courville, “Towards end-to-end speech recognition with deep convolutional neural networks,” in INTERSPEECH, 2016

    work page 2016

  3. [3]

    Optimizing FPGA-based accelerator design for deep convolutional neural networks,

    C. Zhang, P. Li, G. Sun, Y . Guan, B. Xiao, and J. Cong, “Optimizing FPGA-based accelerator design for deep convolutional neural networks,” in Proceedings of the ACM/SIGDA International Symposium on Field- Programmable Gate Arrays, pp. 161–170, 2015

    work page 2015

  4. [4]

    An automatic RTL compiler for high-throughput FPGA implementation of diverse deep convolutional neural networks,

    Y . Ma, Y . Cao, S. Vrudhula, and J. Seo, “An automatic RTL compiler for high-throughput FPGA implementation of diverse deep convolutional neural networks,” in Proceedings of the International Conference on Field Programmable Logic and Applications (FPL) , pp. 1–8, 2017

    work page 2017

  5. [5]

    Improving the performance of OpenCL-based FPGA accelerator for convolutional neural network,

    J. Zhang and J. Li, “Improving the performance of OpenCL-based FPGA accelerator for convolutional neural network,” in Proceedings of the ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA), pp. 25–34, 2017

    work page 2017

  6. [6]

    A framework for generat- ing high throughput CNN implementations on FPGAs,

    H. Zeng, R. Chen, C. Zhang, and V . Prasanna, “A framework for generat- ing high throughput CNN implementations on FPGAs,” in Proceedings of the ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA) , pp. 117–126, 2018

    work page 2018

  7. [7]

    Synetgy: Algorithm-hardware co-design for ConvNet accelerators on embedded FPGAs,

    Y . Yang, Q. Huang, B. Wu, T. Zhang, L. Ma, G. Gambardella, M. Blott, L. Lavagno, K. Vissers, J. Wawrzynek, and K. Keutzer, “Synetgy: Algorithm-hardware co-design for ConvNet accelerators on embedded FPGAs,” in Proceedings of the ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (FPGA) , pp. 23–32, 2019

    work page 2019

  8. [8]

    TrainWare: A memory optimized weight update architecture for on-device convolutional neural network training,

    S. Choi, J. Sim, M. Kang, and L.-S. Kim, “TrainWare: A memory optimized weight update architecture for on-device convolutional neural network training,” in Proceedings of the International Symposium on Low Power Electronics and Design (ISLPED) , 2018

    work page 2018

Show all 25 references
  1. [9]

    In-datacenter performance analysis of a tensor processing unit,

    N. P. Jouppi, C. Young, N. Patil, D. Patterson, G. Agrawal, R. Bajwa, S. Bates, S. Bhatia, N. Boden, A. Borchers, et al. , “In-datacenter performance analysis of a tensor processing unit,” in Proceedings of the ACM/IEEE Annual International Symposium on Computer Architecture (...

    2017

  2. [10]

    Deep learning with limited numerical precision,

    S. Gupta, A. Agrawal, K. Gopalakrishnan, and P. Narayanan, “Deep learning with limited numerical precision,” in Proceedings of the In- ternational Conference on Machine Learning (ICML) , pp. 1737–1746, 2015

    2015

  3. [11]

    Flexpoint: An adaptive numerical format for efficient training of deep neural networks,

    U. K ¨oster, T. Webb, X. Wang, M. Nassar, A. K. Bansal, W. Constable, O. Elibol, S. Gray, S. Hall, L. Hornof, A. Khosrowshahi, C. Kloss, R. J. Pai, and N. Rao, “Flexpoint: An adaptive numerical format for efficient training of deep neural networks,” in Advances in Neural Inform...

    2017

  4. [12]

    Design of an energy-efficient accelerator for training of convolutional neural networks using frequency-domain computation,

    J. H. Ko, B. Mudassar, T. Na, and S. Mukhopadhyay, “Design of an energy-efficient accelerator for training of convolutional neural networks using frequency-domain computation,” in Proceedings of the ACM/EDAC/IEEE Design Automation Conference (DAC), pp. 1–6, 2017

    2017

  5. [13]

    meProp: sparsified back propagation for accelerated deep learning with reduced overfitting,

    X. Sun, X. Ren, S. Ma, and H. Wang, “meProp: sparsified back propagation for accelerated deep learning with reduced overfitting,” in Proceedings of the International Conference on Machine Learning (ICML), pp. 3299–3308, 2017

    2017

  6. [14]

    Can FPGAs beat GPUs in accelerating next-generation deep neural networks?,

    E. Nurvitadhi, G. Venkatesh, J. Sim, D. Marr, R. Huang, J. Ong Gee Hock, Y . T. Liew, K. Srivatsan, D. Moss, S. Subhaschandra, et al., “Can FPGAs beat GPUs in accelerating next-generation deep neural networks?,” in Proceedings of ACM/SIGDA International Symposium on Field-Prog...

    2017

  7. [15]

    Deep neural network approximation for custom hardware: Where we’ve been, where we’re going,

    E. Wang, J. J. Davis, R. Zhao, H.-C. Ng, X. Niu, W. Luk, P. Y . Cheung, and G. A. Constantinides, “Deep neural network approximation for custom hardware: Where we’ve been, where we’re going,”arXiv preprint arXiv:1901.06955, 2019

    1901 arXiv

  8. [16]

    Fast neural network training on FPGA using quasi-newton optimization method,

    Q. Liu, J. Liu, R. Sang, J. Li, T. Zhang, and Q. Zhang, “Fast neural network training on FPGA using quasi-newton optimization method,” IEEE Transactions on Very Large Scale Integration (VLSI) Systems , vol. 26, no. 8, pp. 1575–1579, 2018

    2018

  9. [17]

    Development and implementation of parameterized FPGA-based general purpose neural networks for online applications,

    A. Gomperts, A. Ukil, and F. Zurfluh, “Development and implementation of parameterized FPGA-based general purpose neural networks for online applications,”IEEE Transactions on Industrial Informatics, vol. 7, no. 1, pp. 78–89, 2011

    2011

  10. [18]

    FPGA implementation of a pipelined on-line backpropagation,

    G. Rafael, C. Ricardo, C. Joaqu ´ın, C. Angel, and W. M. Maeda, “FPGA implementation of a pipelined on-line backpropagation,”Journal of VLSI Signal Processing, vol. 40, no. 2, pp. 189–213, 2005

    2005

  11. [19]

    An FPGA-based processor for training convolutional neural networks,

    Z. Liu, Y . Dou, J. Jiang, Q. Wang, and P. Chow, “An FPGA-based processor for training convolutional neural networks,” in Proceedings of the International Conference on Field Programmable Technology (ICFPT), pp. 207–210, 2017

    2017

  12. [20]

    F-CNN: An FPGA-based framework for training convolutional neu- ral networks,

    W. Zhao, H. Fu, W. Luk, T. Yu, S. Wang, B. Feng, Y . Ma, and G. Yang, “F-CNN: An FPGA-based framework for training convolutional neu- ral networks,” in Proceedings of the IEEE International Conference on Application-specific Systems, Architectures and Processors (ASAP) , pp. 10...

    2016

  13. [21]

    Deeptrain: A programmable embedded platform for training deep neural networks,

    D. Kim, T. Na, S. Yalamanchili, and S. Mukhopadhyay, “Deeptrain: A programmable embedded platform for training deep neural networks,” IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, vol. 37, no. 11, pp. 2360–2370, 2018

    2018

  14. [22]

    FxpNet: training a deep convo- lutional neural network in fixed-point representation,

    X. Chen, X. Hu, H. Zhou, and N. Xu, “FxpNet: training a deep convo- lutional neural network in fixed-point representation,” in Proceedings of the IEEE International Joint Conference on Neural Networks (IJCNN) , pp. 2494–2501, 2017

    2017

  15. [23]

    Intel Stratix 10 GX Development Kit

    “Intel Stratix 10 GX Development Kit.” https://www.intel.com/content/ www/us/en/programmable/products/boards and kits/dev-kits/altera/ kit-s10-fpga.html

  16. [24]

    Automatic differentiation in PyTorch,

    A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer, “Automatic differentiation in PyTorch,” in NIPS 2017 Autodiff Workshop , 2017

    2017

  17. [25]

    Revisiting small batch training for deep neural networks,

    D. Masters and C. Luschi, “Revisiting small batch training for deep neural networks,” arXiv preprint arXiv:1804.07612 , 2018

    2018 arXiv

Pith tools

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