Pith. sign in

REVIEW 4 major objections 5 minor 24 references

Efficient FPGA Implementation of Time-Domain Popcount for Low-Complexity Machine Learning

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 establishes that a time-domain popcount built from programmable delay lines and arbiters can replace adder-based vote counting in a Tsetlin Machine, reporting up to 38% lower latency, 43.1% lower dynamic power, and 15% lower…

desk verdict First physical FPGA evidence for PDL-based time-domain popcount, but the weight-only claim needs within-weight spread data before the 'popcount' label holds. read the letter →

arxiv 2505.02181 v1 pith:B5MPN43N submitted 2025-05-04 cs.LG cs.AR

Shengyu Duan , Marcos L. L. Sartori , Rishad Shafik , Alex Yakovlev , Emre Ozer This is my paper · ORCID
classification cs.LGcs.AR
keywords time-domainpopcountprogrammabledelaylineTsetlinMachineasynchronouslogicFPGAimplementationargmaxHammingweightlow-complexitylearning
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 population count and class comparison—the bottleneck of Tsetlin Machine inference—can be moved from digital adder trees into the time domain, where a count becomes a delay and the largest count is simply the signal that arrives first. It reports that programmable delay lines implemented in FPGA lookup tables give a monotonic, near-linear mapping from Hamming weight to propagation delay, and that arbiters can perform the argmax by racing the delayed signals. If true, the result matters because it removes the clocked worst-case path from the voting step and makes inference latency depend on the actual inputs, not on the slowest possible input. The paper demonstrates this in an asynchronous Tsetlin Machine, claiming up to 38% lower latency, 43.1% lower dynamic power, and up to 15% resource savings against adder-based synchronous designs while keeping classification accuracy lossless.

What carries the argument

The programmable delay line (PDL) is the load-bearing object: a cascade of LUT-based delay elements in which each element offers a high-latency net and a low-latency net, selected by one input bit, so that a 0/1 for a positive clause or the reversed polarity for a negative clause adds one unit of delay. The total delay of the chain is inversely proportional to the Hamming weight of the input code, turning popcount into a time measurement. The second mechanism is the arbiter—a NAND SR latch placed symmetrically between two PDLs—that decides which transition arrived first, performing the comparison; completion detection and a two-phase handshake make the result naturally self-timed. The supporting design flow (identical geometric placement, pin assignment to the fastest physical pins, delay-range routing) is what makes the monotonic delay-to-weight mapping actually hold on commercial FPGAs.

What would settle it

Take a second FPGA of the same part, place the same PDL design, and measure propagation delay against Hamming weight over a range of supply voltages and temperatures; if the delay-weight curve stops being monotonic—rank correlation coefficient moving far from $-1$—or if a fixed classifier's accuracy drops below the trained baseline on the same inputs, the paper's central claim is refuted.

Watch

Extended reading notes

Core claim

The central discovery is that a programmable delay line (PDL) of cascaded LUT delay elements can act as a popcounter: each input bit of the code selects, through a multiplexer, either a short or a long routing delay, so the total propagation delay falls as the number of ones rises. With symmetric placement of the PDLs, deliberate physical pin assignment to the fastest LUT inputs, and delay-constrained routing, the measured delay decreases monotonically with input Hamming weight, with rank correlation coefficient of $-0.9897$ for a 60 ps delay difference and $-0.9981$ for a 600 ps difference. An arbiter built from cross-coupled NAND gates then reports which of two PDLs finished first, implementing the argmax in essentially constant time regardless of the number of classes. Integrated in a single-rail, two-phase asynchronous TM pipeline, this replaces adder-tree popcount and digital comparators, and the paper reports that the time-domain version reduces latency, dynamic power, and resource use while preserving the trained model's classification accuracy.

Load-bearing premise

The central claim stands or falls on whether manual placement, pin assignment, and routing can keep every delay element's short and long paths uniform enough that total PDL delay stays monotonic in Hamming weight across boards, voltage, and temperature.

Editorial extensions

If this is right

  • For multi-class tasks, comparison latency grows linearly with class count in adder-based designs but stays nearly constant here, so the advantage widens as classes are added.
  • Popcount and comparison no longer sit on the worst-case clock path; average-case latency over real inputs can replace the critical-path bound, especially for larger clause counts.
  • Dynamic power becomes far less sensitive to input switching activity, simplifying power management for battery-operated ML devices.
  • The same PDL-plus-arbiter structure can be reused in other bit-wise classifiers, with the paper outlining a natural extension to binarized neural networks.
  • Resource savings persist as the model scales: the time-domain design consistently shows the smallest increase in LUT-plus-FF count when clauses or classes grow.

Reading between the lines

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

  • My inference: if monotonicity holds across temperature and supply-voltage corners, the time-domain vote could be paired with a small training or adaptation loop, since per-sample latency already reflects input difficulty and could be traded against energy.
  • My inference: the manual trial-and-error tuning of the delay difference suggests an automated calibration routine—for example, sweeping the delay constraint on-chip and checking a known-weight vector—could make the design portable across boards without redesign.
  • My inference: because the argmax compares arrival times in parallel, the same mechanism could accelerate any winner-take-all over bit-vectors, including k-winner or top-k selection, by cascading arbiter levels.
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

4 major / 5 minor

Summary. This paper proposes implementing the popcount and argmax operations of Tsetlin Machine (TM) inference in the time domain on FPGA. Each class's clause outputs select low- or high-latency paths through a programmable delay line (PDL), and an arbiter compares arrival times to select the class with the highest Hamming weight. The authors describe a placement, pin-assignment, and routing flow intended to make PDL delay elements uniform, measure the delay-versus-Hamming-weight response on a Xilinx Zynq FPGA, and integrate the popcount into a MOUSETRAP-based asynchronous TM. They report up to 38% lower inference latency, up to 43.1% lower dynamic power, and up to 15% lower resource utilization compared with synchronous adder-based TM implementations.

Significance. The paper addresses a real bottleneck: popcount and argmax dominate TM inference latency and resources. The central mechanism, converting Hamming weight to a monotonic delay, is physically plausible, and Fig. 6 provides direct on-FPGA measurements with Spearman rank correlations very close to -1. The reproducible Tcl-based design flow for placement, pin assignment, and routing is a concrete practical contribution, as is the asynchronous TM integration. However, the headline numbers rest on several assumptions that are not yet fully validated: delay must depend only on Hamming weight, not on which bits are set; the per-dataset tuned delay difference must transfer across inputs and boards; and the asynchronous average latency must be compared fairly against synchronous worst-case latency. If these points are addressed, the result would be a useful addition to low-complexity ML hardware and asynchronous FPGA design.

major comments (4)
  1. [Section III-B.4, Fig. 6] The monotonicity evidence does not establish that total PDL delay is a function of Hamming weight alone. The manuscript reports Spearman's rho but does not describe how the weight-varying input vectors were generated, nor does it report the spread of delays at fixed Hamming weight. Because the PDL is a serial chain of LUT-based delay elements, position-dependent routing skew or per-element delay variation can make two inputs with the same Hamming weight produce different total delays and hence different arbiter outcomes. Please provide per-Hamming-weight delay distributions (for example, box plots over many random bit assignments) and, ideally, demonstrate that all same-weight vectors produce identical arbiter decisions.
  2. [Section IV-B, Table I] The high-latency net delay is tuned per dataset by trial and error to the smallest value that gives 'lossless accuracy' (641.9 ps, 593 ps, 603.3 ps, and 632.1 ps in Table I). This makes the accuracy-preservation claim a calibration result rather than an independent prediction. Please define explicitly what 'lossless' is measured against (for example, exact software TM arithmetic), provide a sensitivity analysis around the tuned delay difference, and test at least one additional board or varied voltage/temperature conditions, or state the operating envelope within which the monotonicity and accuracy claims hold.
  3. [Section IV-C.1, Figs. 9(a) and 10] The latency comparison is asymmetric: the asynchronous design's latency is reported as the average over 100 samples, while the synchronous designs are evaluated using the minimal clock period, i.e., the worst-case critical path. Figure 10 shows that the time-domain worst-case latency is substantially larger than the average, so the 'up to 38% lower latency' claim is not a worst-case improvement. Please report the asynchronous worst-case latency (or, alternatively, the average throughput of the synchronous designs) to provide a like-for-like comparison.
  4. [Section IV-C.3, Figs. 9(c) and 12] The dynamic power comparison is also asymmetric: the synchronous designs' dynamic power is taken from Vivado implementation reports and includes clock-tree switching, while the asynchronous design has no clock. This makes the reported power reduction partly a consequence of the chosen comparison baseline. Please separate the clock-tree contribution from the logic power, or provide on-chip power measurements, before claiming a 43.1% dynamic-power reduction.
minor comments (5)
  1. [Section III-A.2] The text states that the high-latency net delay is adjusted during routing to 'minimize the delay difference' relative to the low-latency net, but then says the goal is to ensure 'adequate granularity and resolution'; please clarify whether the objective is to minimize the difference or to set it to a specific target value.
  2. [Section IV-B, Table I] The accuracy values in Table I are reported without showing the baseline accuracy of the same TM models computed with exact arithmetic; please state the reference used to define 'lossless accuracy'.
  3. [Fig. 6] Adding error bars or confidence intervals for the measured delays at each Hamming weight would strengthen the figure; the Spearman rho values are statistically meaningful with 150 points, but the current plot does not show the spread of equal-weight measurements.
  4. [Section IV-A, Fig. 8] The signal transition graph is described informally; labeling the transitions and states in Fig. 8 explicitly would improve reproducibility for readers who want to reimplement the asynchronous controller.
  5. [Section IV-C.2, Fig. 9(b)] The resource comparison treats LUTs and FFs as equally weighted; since their area and routing impact differ on modern FPGAs, reporting them separately or using a weighted metric would make the 15% resource-saving claim easier to interpret.

Circularity Check

1 steps flagged · score 3.0 of 10

Lossless-accuracy claim is a calibration target, but the efficiency results are independently measured.

  1. fitted input called prediction [Section IV-B, Experimental Setup, PDL delay tuning paragraph]
    "For PDLs, we set the low-latency net delay to the smallest possible value and adjust the high-latency net delay using trial and error to determine the minimum delay that ensures lossless accuracy."

    The reported 'lossless accuracy' of the time-domain popcount is not derived or predicted; it is the stopping condition of a per-dataset, per-board tuning loop. The high-latency net delay (the only free PDL parameter) is adjusted until the hardware accuracy equals the software TM baseline, so the subsequent statement that the implementation maintains lossless accuracy is true by construction rather than by independent validation. This circularity is local: it does not contaminate the measured latency, power, or resource comparisons, which are post-implementation measurements with no target fitting.

full rationale

The central efficiency claims (up to 38% lower latency, up to 43.1% lower dynamic power, up to 15% lower resources) are obtained from Vivado implementation reports and timing measurements after the PDL delay is fixed; they are not fitted to match a predetermined outcome. The monotonic delay-versus-Hamming-weight response is also a direct board measurement (Spearman rho), and the linear dependence is by design (each '1' selects the shorter delay net), so no hidden equivalence to the accuracy target appears there. The only reduction-to-input I can exhibit is the 'lossless accuracy' assertion in Section IV-B: the high-latency delay is tuned by trial and error until accuracy is lossless, making that assertion a calibration result rather than an independent prediction. No load-bearing self-citation, imported uniqueness theorem, or ansatz-via-citation pattern occurs; the citation to [16] is used only to motivate the need for physical implementation and is not load-bearing. Validation gaps such as the absence of monotonicity data at the deployed 233 ps delay difference and the lack of board-to-board/PVT variation testing are correctness risks, not circularity, and are noted as such.

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

No new physical entities are introduced. The design leans on two load-bearing empirical assumptions: physical uniformity of delay elements and monotonicity of cumulative delay; it also uses one fitted delay parameter per model. The comparison basis for latency is an ad hoc modeling choice that should be flagged.

free parameters (1)
  • high_latency_net_delay = 593 to 641.9 ps per delay element depending on model; low-latency 371.1 to 402.8 ps (Table I)
    Adjusted by trial and error per dataset/model to the minimum value that preserves TM classification accuracy; the claimed lossless accuracy and the latency/power numbers depend on this calibrated value.
assumptions (4)
  • domain assumption Total PDL propagation delay is the sum of per-delay-element path delays selected by the input bits; higher Hamming weight selects shorter paths and therefore yields smaller total delay.
    This additivity is assumed throughout Section III-A and is core to mapping Hamming weight to delay; routing and LUT internal delays are assumed to be well modeled by the chosen high/low net delays.
  • domain assumption Manual placement, pin assignment, and routing constraints can make all delay elements and both PDLs physically uniform enough that cumulative delay skew is negligible relative to the tuned delay difference.
    Section III-B describes the flow and shows one symmetric layout (Fig. 5); the assumption is validated on a single board only, not across voltage, temperature, or multiple devices.
  • domain assumption Arbiters resolve comparisons correctly whenever arrival times differ by more than the metastability window; identical arrival times may resolve arbitrarily and that is acceptable for argmax.
    Section III-A3 states metastability may occur only for equal Hamming weights and treats arbitrary tie-breaking as acceptable for ML argmax.
  • ad hoc to paper Comparing average asynchronous latency to worst-case synchronous clock period is a fair basis for reporting inference latency improvement.
    Section IV-C defines latency this way; this asymmetric basis can favor the asynchronous design and is not a standard worst-case comparison.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Efficient FPGA Implementation of Time-Domain Popcount for Low-Complexity Machine Learning." pith.science (2026). https://pith.science/paper/B5MPN43N

@misc{pith2026250502181,
  author       = {Pith},
  title        = {Pith review of: Efficient FPGA Implementation of Time-Domain Popcount for Low-Complexity Machine Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/B5MPN43N}},
  note         = {Machine review of arXiv:2505.02181}
}
read the original abstract

Population count (popcount) is a crucial operation for many low-complexity machine learning (ML) algorithms, including Tsetlin Machine (TM)-a promising new ML method, particularly well-suited for solving classification tasks. The inference mechanism in TM consists of propositional logic-based structures within each class, followed by a majority voting scheme, which makes the classification decision. In TM, the voters are the outputs of Boolean clauses. The voting mechanism comprises two operations: popcount for each class and determining the class with the maximum vote by means of an argmax operation. While TMs offer a lightweight ML alternative, their performance is often limited by the high computational cost of popcount and comparison required to produce the argmax result. In this paper, we propose an innovative approach to accelerate and optimize these operations by performing them in the time domain. Our time-domain implementation uses programmable delay lines (PDLs) and arbiters to efficiently manage these tasks through delay-based mechanisms. We also present an FPGA design flow for practical implementation of the time-domain popcount, addressing delay skew and ensuring that the behavior matches that of the model's intended functionality. By leveraging the natural compatibility of the proposed popcount with asynchronous architectures, we demonstrate significant improvements in an asynchronous TM, including up to 38% reduction in latency, 43.1% reduction in dynamic power, and 15% savings in resource utilization, compared to synchronous TMs using adder-based popcount.

Figures

Figures reproduced from arXiv: 2505.02181 by the authors.

Figure 1
Figure 1. (a) TMs, where each TM is assigned to a certain class [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Time-domain popcount and comparison, implemented [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 3
Figure 3. With all delay elements placed at identical geometric [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (8 more)
Figure 5
Figure 5. Figure 5: Symmetric PDL and delay element layout. 4) Evaluation of Hamming weight response: An ideal time-domain popcount requires a monotonically decreasing propagation delay through the PDL as the input Hamming weight increases. We assess the likelihood of achieving this monot…
Figure 4
Figure 4. Figure 4: PDL placement on Xilinx FPGA, where each CLB [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 7
Figure 7. Figure 7: Asynchronous TM architecture, integrating a MOUSE [PITH_FULL_IMAGE:figures/full_fig_p005_7.png]
Figure 8
Figure 8. Figure 8: STG for asynchronous TM, with the dotted arc as a [PITH_FULL_IMAGE:figures/full_fig_p006_8.png]
Figure 9
Figure 9. Figure 9: Comparison of (a) inference latency, (b) resource utilization, and (c) dynamic power for TMs across different [PITH_FULL_IMAGE:figures/full_fig_p007_9.png]
Figure 10
Figure 10. Figure 10: Latency vs. (a) clauses (6 classes) and (b) classes (100 [PITH_FULL_IMAGE:figures/full_fig_p007_10.png]
Figure 12
Figure 12. Figure 12: Power vs. (a) clauses (6 classes) and (b) classes (100 [PITH_FULL_IMAGE:figures/full_fig_p008_12.png]
Figure 11
Figure 11. Figure 11: Resource vs. (a) clauses (6 classes) and (b) classes [PITH_FULL_IMAGE:figures/full_fig_p008_11.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

24 extracted references · 20 canonical work pages

  1. [16]

    An asynchronous winner-takes-all arbitration architecture for Tsetlin machine acceleration,

    T. Lan et al., “An asynchronous winner-takes-all arbitration architecture for Tsetlin machine acceleration,” in 22nd Interregional NEWCAS Conf. (NEWCAS). IEEE, 2024, pp. 16–20

    work page 2024

  2. [1]

    The Tsetlin machine–a game theoretic bandit driven approach to optimal pattern recognition with propositional logic,

    O.-C. Granmo, “The Tsetlin machine–a game theoretic bandit driven approach to optimal pattern recognition with propositional logic,” arXiv preprint arXiv:1804.01508, 2018

    arXiv 2018

  3. [2]

    Binarized neural networks: Training deep neural networks with weights and activations constrained to +1 or -1,

    M. Courbariaux et al., “Binarized neural networks: Training deep neural networks with weights and activations constrained to +1 or -1,” arXiv preprint arXiv:1602.02830, 2016

    arXiv 2016

  4. [3]

    Photonic processor for fully discretized neural networks,

    J. Anderson et al. , “Photonic processor for fully discretized neural networks,” in 30th Int. Conf. on Appl.-Specific Syst., Architectures and Processors (ASAP), vol. 2160. IEEE, 2019, pp. 25–32

    work page 2019

  5. [4]

    Efficient FPGA implementation of binarized neural networks based on generalized parallel counter tree,

    T. Tanigawa et al., “Efficient FPGA implementation of binarized neural networks based on generalized parallel counter tree,” in Proc. the Workshop on Synthesis And Syst. Integration of Mixed Information Technol. (SASIMI), 2024, pp. 32–37

    work page 2024

  6. [5]

    FPGA logic cell improvements for popcount computation in BNN,

    Z. Li et al., “FPGA logic cell improvements for popcount computation in BNN,” in 16th Int. Conf. on Solid-State & Integrated Circuit Technol. (ICSICT). IEEE, 2022, pp. 1–3

    work page 2022

  7. [6]

    FPGA architecture enhancements for efficient BNN implementation,

    J. H. Kim et al. , “FPGA architecture enhancements for efficient BNN implementation,” in Int. Conf. on Field-Programmable Technol. (FPT) . IEEE, 2018, pp. 214–221

    work page 2018

  8. [7]

    FPGA optimized architecture of XNOR-POPCOUNT,

    T. Ma et al. , “FPGA optimized architecture of XNOR-POPCOUNT,” in 2nd Int. Conf. on Computing, Commun., Perception and Quantum Technol. (CCPQT). IEEE, 2023, pp. 235–239

    work page 2023

Show all 24 references
  1. [8]

    MOUSETRAP: High-speed transition-signaling asyn- chronous pipelines,

    M. Singh et al., “MOUSETRAP: High-speed transition-signaling asyn- chronous pipelines,” IEEE Trans. Very Large Scale Integr. (VLSI) Syst. , vol. 15, no. 6, pp. 684–698, 2007

    2007

  2. [9]

    New hardware architecture for bit-counting,

    A. Dalalah et al., “New hardware architecture for bit-counting,” in Proc. of the 5th WSEAS Int. Conf. on Applied comput. sci., 2006, pp. 118–128

    2006

  3. [10]

    FP-BNN: Binarized neural network on FPGA,

    S. Liang et al., “FP-BNN: Binarized neural network on FPGA,” Neuro- computing, vol. 275, pp. 1072–1086, 2018

    2018

  4. [11]

    Compact hamming-comparator-based rank order filter for digital VLSI and FPGA implementations,

    V . A. Pedroni, “Compact hamming-comparator-based rank order filter for digital VLSI and FPGA implementations,” in IEEE Int. Symp. on Circuits and Syst. , vol. 2. IEEE, 2004, pp. II–585

    2004

  5. [12]

    FPGA PUF using programmable delay lines,

    M. Majzoobi et al. , “FPGA PUF using programmable delay lines,” in IEEE Int. workshop on inf. forensics and Secur. IEEE, 2010, pp. 1–6

    2010

  6. [13]

    An efficient implementation of arbiter PUF on FPGA for IoT application,

    M. H. Mahalat et al. , “An efficient implementation of arbiter PUF on FPGA for IoT application,” in 32nd IEEE Int. Syst.-on-Chip Conf. (SOCC). IEEE, 2019, pp. 324–329

    2019

  7. [14]

    Implementation of efficient XOR arbiter PUF on FPGA with enhanced uniqueness and security,

    N. N. Anandakumar et al. , “Implementation of efficient XOR arbiter PUF on FPGA with enhanced uniqueness and security,” IEEE Access , vol. 10, pp. 129 832–129 842, 2022

    2022

  8. [15]

    Towards ideal arbiter PUF design on Xilinx FPGA: A practitioner’s perspective,

    D. P. Sahoo et al., “Towards ideal arbiter PUF design on Xilinx FPGA: A practitioner’s perspective,” in Euromicro Conf. on Digital Syst. Design . IEEE, 2015, pp. 559–562

    2015

  9. [17]

    Vivado Design Suite Properties Reference Guide , UG912 ed., AMD Xilinx, June 2022, available at https://www.xilinx.com/support/documents/sw manuals/xilinx2022 1/ug912- vivado-properties.pdf

    2022

  10. [18]

    Softermax: Hardware/software co-design of an efficient softmax for transformers,

    J. R. Stevens et al. , “Softermax: Hardware/software co-design of an efficient softmax for transformers,” in 58th ACM/IEEE Design Automat. Conf. (DAC), 2021, pp. 469–474

    2021

  11. [19]

    Rapid FPGA characterization using clock synthesis and signal sparsity,

    M. Majzoobi et al., “Rapid FPGA characterization using clock synthesis and signal sparsity,” in Int. Test Conf. (ITC) , 2010, pp. 1–10

    2010

  12. [20]

    R. A. Fisher, “Iris,” UCI Mach. Learning Repository, 1988, DOI: https://doi.org/10.24432/C56C76

    1988 doi

  13. [21]

    The MNIST database of handwritten digit images for machine learning research,

    L. Deng, “The MNIST database of handwritten digit images for machine learning research,” IEEE Signal Process. Mag. , vol. 29, no. 6, pp. 141– 142, 2012

    2012

  14. [22]

    Data booleanization for energy efficient on-chip learning using logic driven AI,

    T. Rahman et al. , “Data booleanization for energy efficient on-chip learning using logic driven AI,” in Int. Symp. on the Tsetlin Mach. (ISTM). Grimstad, Norway: IEEE, 2022, pp. 29–36

    2022

  15. [23]

    Systematic search for optimal hyper-parameters of the tsetlin machine on MNIST dataset,

    O. Tarasyuk et al., “Systematic search for optimal hyper-parameters of the tsetlin machine on MNIST dataset,” in Int. Symp. on the Tsetlin Mach. (ISTM). IEEE, 2023, pp. 1–8

    2023

  16. [24]

    Self-timed reinforcement learning using tsetlin machine,

    A. Wheeldon et al. , “Self-timed reinforcement learning using tsetlin machine,” in 27th Int. Symp. on Asynchronous Circuits and Syst. (ASYNC). IEEE, 2021, pp. 40–47. 9

    2021

Pith tools

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