Pith. sign in

REVIEW 5 major objections 5 minor 1 cited by

Runtime Tunable Tsetlin Machines for Edge Inference on eFPGAs

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

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

Pith's one-line read This paper claims that Tsetlin Machine inference on embedded FPGAs can be made both resource-frugal and runtime-tunable by compressing the model to a sparse Include-only instruction set, achieving 2.5x fewer LUTs than the closest prior…

desk verdict Resource numbers are credible, but the compressed inference silently drops all-Exclude clauses, so the accelerator may not compute the class sums of the TM it claims to implement. read the letter →

arxiv 2502.07823 v1 pith:JABGWCWI submitted 2025-02-10 cs.AR cs.AIcs.LG

Tousif Rahman , Gang Mao , Bob Pattison , Sidharth Maheshwari , Marcos Sartori , Adrian Wheeldon , Rishad Shafik , Alex Yakovlev This is my paper · ORCID
classification cs.ARcs.AIcs.LG
keywords TsetlinMachineeFPGAinferenceacceleratorruntimetunabilitycompressedInclude-onlyencodingedgelearningresourcefrugality
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 claims that Tsetlin Machine inference on embedded FPGAs can be made resource-frugal and runtime-tunable by compressing each trained model to its sparse set of Include Tsetlin Automata actions, encoded as 16-bit instructions. The accelerator can then change model size, architecture, and input dimensionality at runtime by streaming a new instruction set, without offline resynthesis. The authors report 2.5x fewer look-up tables and 3.38x fewer flip-flops than the closest prior TM accelerator on MNIST, and energy reductions up to 129x versus a low-power microcontroller on some datasets. The significance would be a practical route to on-field recalibration of edge ML models on small eFPGAs.

What carries the argument

The load-bearing mechanism is the Include-only compressed inference driven by the 16-bit Include Instruction Encoding: an offset field that jumps from one Include TA to the next, a literal bit L that selects the feature or its complement, a clause toggle CC and polarity toggle +/- that mark clause boundaries, and an added class toggle E. This encoding lets the accelerator reconstruct each clause's output in the correct order while skipping all Exclude TAs, and the same instruction stream doubles as the model specification, which is what makes runtime tunability possible.

What would settle it

Train a Tsetlin Machine on a benchmark dataset, encode it with the Include Instruction Encoding, and run the compressed inference on the accelerator while comparing the class sums against an exact software TM inference on the same test datapoints. Any discrepancy in class sums or predicted labels for any single datapoint would falsify the encoding's correctness; stress tests with many classes and clauses would specifically probe the offset and toggle boundary logic.

Watch

Extended reading notes

Core claim

The central claim is that a Tsetlin Machine's inference can be performed correctly and frugally by ignoring all Exclude TAs and iterating only over the sparse Include TAs, using a 16-bit Include Instruction Encoding that carries an offset, a literal complement bit, and toggle bits for clause and class boundaries. Skipping Excludes does not change clause outputs because an Exclude merely removes a literal from the clause's conjunction; only Includes propagate a Boolean literal. The accelerator fetches these instructions from on-chip block RAM, decodes them, selects literals, ANDs them into clause accumulators, and accumulates polarity-weighted clause outputs into class sums, taking the argmax. Because the entire compressed model fits in block RAM and the instruction stream defines the model, the accelerator can be reprogrammed in the field by writing new instructions, without resynthesis.

Load-bearing premise

Compressed inference is correct only if the 16-bit Include Instruction Encoding unambiguously reconstructs every Include TA in the right order, and skipping all Exclude TAs never changes a clause output or class sum; any mis-decoded offset, toggle, or complement bit silently corrupts the result.

Editorial extensions

If this is right

  • Edge ML models can be recalibrated on-field by streaming new instruction sets, without regenerating a bitstream.
  • The resource savings (2.5x fewer LUTs, 3.38x fewer FFs vs the closest prior TM accelerator on MNIST) could let TM accelerators fit on smaller, cheaper, lower-power eFPGAs.
  • The compressed instruction format allows the entire TM model to reside in on-chip block RAM, removing external memory traffic during inference.
  • Energy reductions up to 129x versus a low-power microcontroller on some datasets suggest that, for drift-prone or personalized edge tasks, the eFPGA path can be far more efficient than MCU software.

Reading between the lines

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

  • A natural testable extension is to verify the encoding's correctness on larger TMs (more classes, longer clauses) where offset and toggle boundary errors would surface as accuracy drops; the paper does not provide a formal proof of the encoding's completeness.
  • The runtime-tunability argument implicitly supports continual learning or personalization at the edge, but the paper does not measure reconfiguration latency or the energy cost of streaming a new model; those numbers would be needed for real deployment decisions.
  • The same Include-only compressed instruction idea could likely be adapted to other sparse logic-based models, not just Tsetlin Machines, if they admit an Include/Exclude decomposition.
  • The resource comparison is against a prior accelerator synthesized for fixed models; if that prior design were given the same runtime reconfiguration ability, the trade-off might shift, but its architecture-specific synthesis makes that impossible.
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

5 major / 5 minor

Summary. This paper proposes a Tsetlin Machine (TM) inference accelerator for eFPGAs that stores a compressed representation of the TM as a stream of 16-bit Include Instructions, allowing model size, number of classes, and input dimensionality to be changed at runtime without resynthesis. Three configurations (base, single-core with AXI-Stream, and multi-core) are implemented on Xilinx Artix-7/Zynq parts. The paper reports lower LUT/FF usage than the prior MATADOR accelerator (2.5x fewer LUTs and 3.38x fewer FFs for MNIST) and large energy reductions versus an ESP32 running the same compressed algorithm. The contributions are the compression-based architecture, the runtime-tunability strategy, and the resource/energy evaluation.

Significance. If the correctness of the compressed instruction stream can be established, the paper's resource-frugal direction is a useful complement to throughput-oriented FPGA accelerators. The reported LUT/FF counts are detailed enough to verify the resource reductions, and the idea of storing the model as instructions in BRAM is concrete and promising. However, the lack of a correctness proof or end-to-end accuracy check for the decoding, the unmeasured runtime-reconfiguration claim, and the absent energy/latency methodology currently leave the main performance claims insufficiently supported. The empty-clause issue, if real, would require a design modification but is likely addressable with a bias term or a small encoding extension.

major comments (5)
  1. [§3, Fig. 4 and 'Compressed Inference'] The 16-bit Include Instruction Encoding omits Exclude TAs, and the paper claims this does not change clause outputs. This is only true for clauses with at least one Include. A clause whose TAs are all Exclude has vacuous output 1 and contributes its polarity (+1 or −1) to the class sum in the original TM. Because no instruction is emitted for such a clause, the CC/+/- toggle never fires on that clause boundary, so the class-sum accumulator never receives this constant contribution. Moreover, the offset field counts TAs, not clause boundaries, and a single CC bit can only signal one boundary per instruction; if the next Include is several clauses away, the multiple skipped empty clauses cannot be represented. The paper does not state that the trained models contain no empty clauses, nor does it describe a bias/empty-clause mechanism. Please resolve by (a) proving or empirically showing that all-Exclude clauses do not occur in the datasets used (e.g., a count of empty clauses per trained model), or (b) extending the instruction set or class-sum initialization to account for the constant contributions of empty clauses.
  2. [§4] The abstract and Section 3 claim runtime tunability—changing model size, architecture, and input dimensionality without resynthesis—as the main contribution. However, Section 4 contains no experiment that exercises this capability: there is no measurement of reconfiguration time, energy, or throughput during model update, and no demonstration of switching between two models or changing input dimensionality on the FPGA. Without such evidence, the headline 'runtime tunable' claim is supported only by the design description. Please add an experiment or explicitly delimit the claim as a design property rather than an evaluated one.
  3. [§4, Table 2 and Fig. 9] The energy and latency values in Table 2 and Fig. 9 are the basis for the claimed speedups and energy reductions (e.g., 129x), but no methodology is provided. It is not stated whether these numbers come from physical measurements on the Z7020/Artix boards, from vendor power analysis (e.g., Vivado Power Estimator), from post-synthesis simulation, or from analytic calculation with assumed switching activity. No operating frequency, voltage, or temperature conditions are given, and no run-to-run variation or error bars are reported. Please report the measurement/estimation setup and, if these are estimates, label them as such and provide the underlying power model.
  4. [§4, 'Addressing Question 1'] The paper asserts that using the same TM architectures 'result in the same accuracy' as MATADOR, but it never reports accuracy results from the proposed accelerator or a comparison of its class sums against the original uncompressed TM. Given the compressed instruction decoding and the potential for mis-decoded offsets or toggles, an end-to-end check is necessary: run the accelerator (or a bit-accurate simulation) on the test sets and report the accuracy and/or a classification-match rate against the software TM. Otherwise the reported latency/energy numbers could correspond to an implementation computing different class sums than intended.
  5. [§3, Fig. 3.4] The Include Instruction Encoding is described as 16-bit, but the widths of the O, L, CC, +/-, and E fields are not given. If the offset field is small (for example, 10–12 bits), then gaps between consecutive Include actions longer than 2^W − 1 TAs cannot be represented in a single instruction. With 3.1M TAs and only ~17k Includes in the MNIST example, the maximum gap could exceed typical field widths. Please specify the field widths, the maximum representable offset, and demonstrate that every inter-Include gap in the trained models is encodable (or describe how longer gaps are split into multiple instructions).
minor comments (5)
  1. [Table 2] The sub-columns under 'Latency (us)' and 'Energy (uJ)' appear to be 'Batch' and 'Single data point', but the 'xSpeedups' and 'xEnergy Reduction' columns do not state which of the two modes they refer to. Please label the columns explicitly.
  2. [§1 and §4] The paper uses 'eFPGA' to describe implementations on Artix-7 and Zynq devices, which are conventional FPGAs. Please clarify whether the design targets embedded FPGA IP blocks or commercial off-the-shelf FPGAs, and adjust terminology accordingly.
  3. [§4] The statement that BRAMs are 'over-provisioned for more tunability later' is not quantified. A sentence or small table listing the maximum instruction counts supported by the memory configurations would help the reader understand the trade-off.
  4. [Fig. 8] The on-field recalibration system is only shown as a diagram; neither the model training node nor the communication overhead is evaluated. At minimum, a discussion of the expected update latency and energy for transmitting a new instruction stream would strengthen the runtime-tunability narrative.
  5. [§3] The compression flow that converts a trained TM into 16-bit Include Instructions is not described in enough detail to reproduce. Please provide pseudocode or precisely specify the traversal order and the toggle/offset update rules, including the field widths from Fig. 3.4.

Circularity Check

0 steps flagged · score 2.0 of 10

No circular derivation: the accelerator is a hardware implementation of a previously published compression scheme, and the resource/energy results are measured against independent baselines.

full rationale

The paper does not fit a parameter and then rename it as a prediction. The compressed instruction encoding is inherited from the authors' prior REDRESS work (Ref. 15), but the present claim is a hardware implementation; the LUT/FF/BRAM counts, frequency, latency, and energy numbers come from synthesis and measurement against an external MCU baseline and against MATADOR (Ref. 18, also the authors' prior work). Those comparisons are not predictions derived from the encoding. The statement that Exclude TAs are redundant during inference follows directly from the AND semantics of the clause output in Fig. 3.2, not from a fitted quantity. The runtime-tunability claim is a property of the instruction-stream and header design, demonstrated by construction in Figs. 4-5, not by a circular argument. Self-citations to Refs. 15 and 18 are present but they are used as prior baselines and building blocks, not as the sole justification for the central resource-efficiency claim, so no circular step can be exhibited. The most serious concern is a correctness risk, not circularity: the paper does not prove that an all-Exclude clause, which outputs 1 and contributes its polarity, is representable in the 16-bit instruction stream, since the CC toggle only fires on instructions for Included TAs. If such clauses occur in trained models, the accelerator would compute different class sums from the trained TM, invalidating the reported accuracy, latency, and energy comparisons. This is an implementation/semantics concern, not a case of the paper's conclusion being equivalent to its input, and therefore it does not raise the circularity score.

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

No fitted numeric parameters appear in the paper; all tunable knobs are architecture configuration options. The central claims rest on standard Tsetlin machine properties and on the correctness of a new instruction encoding that is asserted by design rather than proven. No new physical entities are introduced.

assumptions (3)
  • domain assumption TM inference only needs Include TA actions; Exclude actions do not affect clause outputs.
    Used in Section 2 and Fig. 3.2 to justify compressing the model to Include TAs only. This is a standard property of Tsetlin machine clause computation, not derived in this paper.
  • ad hoc to paper The 16-bit Include Instruction Encoding with offset and toggle bits is sufficient to reconstruct all Include TAs in traversal order.
    Section 3 and Fig. 3.4. Any omission or ordering error would break compressed inference, but no formal proof or exhaustive test is given.
  • domain assumption Runtime reconfiguration through instruction headers and memory updates changes model classes and clauses without resynthesis.
    Section 3, Programming for Real-time Adaptability. This relies on writable instruction memory and resettable control logic, which is plausible but not demonstrated experimentally.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Runtime Tunable Tsetlin Machines for Edge Inference on eFPGAs." pith.science (2026). https://pith.science/paper/JABGWCWI

@misc{pith2026250207823,
  author       = {Pith},
  title        = {Pith review of: Runtime Tunable Tsetlin Machines for Edge Inference on eFPGAs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/JABGWCWI}},
  note         = {Machine review of arXiv:2502.07823}
}
read the original abstract

Embedded Field-Programmable Gate Arrays (eFPGAs) allow for the design of hardware accelerators of edge Machine Learning (ML) applications at a lower power budget compared with traditional FPGA platforms. However, the limited eFPGA logic and memory significantly constrain compute capabilities and model size. As such, ML application deployment on eFPGAs is in direct contrast with the most recent FPGA approaches developing architecture-specific implementations and maximizing throughput over resource frugality. This paper focuses on the opposite side of this trade-off: the proposed eFPGA accelerator focuses on minimizing resource usage and allowing flexibility for on-field recalibration over throughput. This allows for runtime changes in model size, architecture, and input data dimensionality without offline resynthesis. This is made possible through the use of a bitwise compressed inference architecture of the Tsetlin Machine (TM) algorithm. TM compute does not require any multiplication operations, being limited to only bitwise AND, OR, NOT, summations and additions. Additionally, TM model compression allows the entire model to fit within the on-chip block RAM of the eFPGA. The paper uses this accelerator to propose a strategy for runtime model tuning in the field. The proposed approach uses 2.5x fewer Look-up-Tables (LUTs) and 3.38x fewer registers than the current most resource-fugal design and achieves up to 129x energy reduction compared with low-power microcontrollers running the same ML application.

Figures

Figures reproduced from arXiv: 2502.07823 by the authors.

Figure 1
Figure 1. Comparing the proposed design (3480 LUTs configuration) to state-of-the-art accelerator automation flows targeting FPGAs. All accelerators were designed for MNIST. Each vertical line indicates the max LUTs of an off-the-shelf eFPGA platform. This work uses 2.5x fewer LUTs than the next closest work (MATADOR) [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. Core components of the Tsetlin Machine: Input conversion to Boolean literals, the Tsetlin Automata (TA) and Clause compute. traditional Deep Neural Networks (DNNs). Fortunately, these chal￾lenges can be somewhat alleviated by quantizing DNN weights and data, often to a single bit producing Binary Neural Networks (BNNs) [2, 5, 6, 17, 28]. This means that the MAC is simplified to XNOR and popcount operations and weigh… view at source ↗
Figure 3
Figure 3. 1: The class sum compute in the original TM algorithm. 2: The impact of Includes and Excludes in the Clause Output computation - showing that excludes become redundant during inference. 3: The traversal of a trained TM model using when only considering included TAs. 4: The encoding instruction used to create a compressed TM model adapted from the approach used by [15]. eFPGA platforms and, crucially, favoring flexib… view at source ↗
Figures from the paper (6 more)
Figure 4
Figure 4. Figure 4: Overview of the Proposed Accelerator (Base Version): 1: An incoming data stream to the accelerator; the header packet of the stream is used for configuration. 2: The bit-fields of the header when the data stream contains instructions (the TM model) 3: The bit-field of …
Figure 5
Figure 5. Figure 5: Timing diagrams of the programming, inference and execution cycle of an instruction (1). The instruction execution cycle (2) is a per-core process - it would be the same for a multi-core version of the accelerator. Memory Customization Options: While the accelerator is…
Figure 6
Figure 6. Figure 6: Customization options for memory depths for the base configuration (implemented on Artix A7-35T) [PITH_FULL_IMAGE:figures/full_fig_p004_6.png]
Figure 7
Figure 7. Figure 7: Block diagram for the multi-core design of the accelerator. Each Inference Core is the base version seen in [PITH_FULL_IMAGE:figures/full_fig_p004_7.png]
Figure 8
Figure 8. Figure 8: Configuration options for the initial deployment and the proposed system for on-field re-calibration and task update [PITH_FULL_IMAGE:figures/full_fig_p005_8.png]
Figure 9
Figure 9. Figure 9: Energy (E) and latency (L) of the proposed accelerator de￾signs (B, S, M) against MATADOR (MTDR) and the same compressed instruction algorithm on the STM32Disco MCU (RDRS). Single dat￾apoint energy and latencies are shown with the hatched bar and batched energy and lat…

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. RoCo-ACE: Rollout-Conditioned Online Distillation for Retention-Aware Knowledge Injection

    cs.AI 2026-06 conditional novelty 6.0 of 10

    A rollout-conditioned contrastive distillation loss plus sparse anchored cross-entropy improves injected-knowledge accuracy in MLLMs while keeping retention close to the base model.

Reference graph

Works this paper leans on

30 extracted references · 11 canonical work pages · cited by 1 Pith paper

  1. [1]

    Darshana Abeyrathna, Ahmed A

    K. Darshana Abeyrathna, Ahmed A. O. Abouzeid, Bimal Bhattarai, Charul Giri, Sondre Glimsdal, Ole-Christoffer Granmo, Lei Jiao, Rupsa Saha, Jivitesh Sharma, Svein A. Tunheim, and Xuan Zhang. 2023. Building concise logical patterns by constraining tsetlin machine clause size. In Proceedings of the Thirty-Second International Joint Conference on Artificial I...

    work page doi:10.24963/ijcai.2023/378 2023

  2. [2]

    Constantinides

    Marta Andronic and George A. Constantinides. 2023. PolyLUT: Learning Piecewise Polynomials for Ultra-Low Latency FPGA LUT-based Inference. In 2023 International Conference on Field Programmable Technology (ICFPT) . 60–68. https://doi.org/10.1109/ICFPT59805.2023.00012

    arXiv 2023

  3. [3]

    Abu Bakar, Tousif Rahman, Rishad Shafik, Fahim Kawsar, and Alessandro Mon- tanari. 2023. Adaptive Intelligence for Batteryless Sensors Using Software- Accelerated Tsetlin Machines. In Proceedings of the 20th ACM Conference on Embedded Networked Sensor Systems (SenSys ’22) . 236–249. https://doi.org/10. 1145/3560905.3568512

    arXiv 2023

  4. [4]

    Martyna Bator. 2013. Dataset for Sensorless Drive Diagnosis. UCI Machine Learning Repository. DOI: https://doi.org/10.24432/C5VP5F

    work page doi:10.24432/c5vp5f 2013

  5. [5]

    Preußer, Nicholas J

    Michaela Blott, Thomas B. Preußer, Nicholas J. Fraser, Giulio Gambardella, Ken- neth O’brien, Yaman Umuroglu, Miriam Leeser, and Kees Vissers. 2018. FINN-R: An End-to-End Deep-Learning Framework for Fast Exploration of Quantized Neural Networks. ACM Trans. Reconfigurable Technol. Syst. 11, 3, Article 16 (dec 2018), 23 pages. https://doi.org/10.1145/3242897

    doi:10.1145/3242897 2018

  6. [6]

    Francesco Conti, Pasquale Davide Schiavone, and Luca Benini. 2018. XNOR Neural Engine: A Hardware Accelerator IP for 21.6-fJ/op Binary Neural Network Inference. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 37, 11 (Nov. 2018), 2940–2951. https://doi.org/10.1109/tcad.2018.2857019

    arXiv 2018

  7. [7]

    Li Deng. 2012. The MNIST database of handwritten digit images for machine learning research. IEEE Signal Processing Magazine 29, 6 (2012), 141–142

    work page 2012

  8. [8]

    Ole-Christoffer Granmo. 2018. The Tsetlin Machine - A Game Theoretic Bandit Driven Approach to Optimal Pattern Recognition with Propositional Logic.CoRR abs/1804.01508 (2018). arXiv:1804.01508

    arXiv 2018

Show all 30 references
  1. [9]

    Lei Jiao, Xuan Zhang, Ole-Christoffer Granmo, and Kuruge Darshana Abeyrathna

  2. [10]

    Krilova, I

    N. Krilova, I. Kastalskiy, V. Kazantsev, V.A. Makarov, and S. Lobov. 2018. EMG Data for Gestures. UCI Machine Learning Repository. DOI: https://doi.org/10.24432/C5ZP5C

    2018 doi

  3. [11]

    Alex Krizhevsky. 2009. Learning multiple layers of features from tiny images . Technical Report. University of Toronto

    2009

  4. [12]

    Jie Lei, Tousif Rahman, Rishad Shafik, Adrian Wheeldon, Alex Yakovlev, Ole- Christoffer Granmo, Fahim Kawsar, and Akhil Mathur. 2021. Low-Power Audio Keyword Spotting Using Tsetlin Machines. Journal of Low Power Electronics and Applications 11, 2 (2021). https://doi.org/10.339...

    2021 doi

  5. [13]

    Jie Lu, Anjin Liu, Fan Dong, Feng Gu, João Gama, and Guangquan Zhang. 2019. Learning under Concept Drift: A Review. IEEE Transactions on Knowledge and Data Engineering 31, 12 (2019), 2346–2363. https://doi.org/10.1109/TKDE.2018. 2876857

    2019 doi

  6. [14]

    Renata Madeo, Priscilla Wagner, and Sarajane Peres. 2013. Gesture Phase Segmen- tation. UCI Machine Learning Repository. DOI: https://doi.org/10.24432/C5Z32C

    2013 doi

  7. [15]

    Sidharth Maheshwari, Tousif Rahman, Rishad Shafik, Alex Yakovlev, Ashur Rafiev, Lei Jiao, and Ole-Christoffer Granmo. 2023. REDRESS: Generating Compressed Models for Edge Inference Using Tsetlin Machines. IEEE Transactions on Pattern Analysis and Machine Intelligence (2023), 1...

    2023

  8. [16]

    Nour Moustafa and Jill Slay. 2015. UNSW-NB15: a comprehensive data set for network intrusion detection systems (UNSW-NB15 network data set). In 2015 Military Communications and Information Systems Conference (MilCIS) . 1–6. https://doi.org/10.1109/MilCIS.2015.7348942

    2015

  9. [17]

    Jennifer Ngadiuba, Vladimir Loncar, Maurizio Pierini, Sioni Summers, Giuseppe Di Guglielmo, Javier Duarte, Philip Harris, Dylan Rankin, Sergo Jindari- ani, Mia Liu, Kevin Pedro, Nhan Tran, Edward Kreinar, Sheila Sagear, Zhenbin Wu, and Duc Hoang. 2020. Compressing deep neural ...

    2020 doi

  10. [18]

    Tousif Rahman, Gang Mao, Sidharth Maheshwari, Rishad Shafik, and Alex Yakovlev. 2024. MATADOR: Automated System-on-Chip Tsetlin Machine Design Generation for Edge Applications. In 2024 Design, Automation and Test in Europe Conference and Exhibition (DATE) . 1–6. https://doi.or...

    2024

  11. [19]

    Jorge Reyes-Ortiz, Davide Anguita, Alessandro Ghio, Luca Oneto, and Xavier Parra. 2013. Human Activity Recognition Using Smartphones. UCI Machine Learning Repository. DOI: https://doi.org/10.24432/C54S4K

    2013 doi

  12. [20]

    Maruf Hossain Shuvo, Syed Kamrul Islam, Jianlin Cheng, and Bashir I

    Md. Maruf Hossain Shuvo, Syed Kamrul Islam, Jianlin Cheng, and Bashir I. Morshed. 2023. Efficient Acceleration of Deep Learning Inference on Resource- Constrained Edge Devices: A Review. Proc. IEEE 111, 1 (2023), 42–91. https: //doi.org/10.1109/JPROC.2022.3226481

    2023

  13. [21]

    Olga Tarasyuk, Anatoliy Gorbenko, Tousif Rahman, Rishad Shafik, Alex Yakovlev, Ole-Christoffer Granmo, and Lei Jiao. 2023. Systematic Search for Optimal Hyper- parameters of the Tsetlin Machine on MNIST Dataset. In Second International Symposium on the Tsetlin Machine

    2023

  14. [22]

    Svein Anders Tunheim, Lei Jiao, Rishad Shafik, Alex Yakovlev, and Ole-Christoffer Granmo. 2022. A Convolutional Tsetlin Machine-based Field Programmable Gate Array Accelerator for Image Classification. In 2022 International Symposium on the Tsetlin Machine (ISTM). 21–28. https...

    2022

  15. [23]

    Yaman Umuroglu, Yash Akhauri, Nicholas James Fraser, and Michaela Blott. 2020. LogicNets: Co-Designed Neural Networks and Circuits for Extreme-Throughput Applications. In 2020 30th International Conference on Field-Programmable Logic and Applications (FPL). 291–297. https://do...

    2020

  16. [24]

    Alexander Vergara. 2012. Gas Sensor Array Drift Dataset. UCI Machine Learning Repository. DOI: https://doi.org/10.24432/C5RP6W

    2012 doi

  17. [25]

    Marian Verhelst and Bert Moons. 2017. Embedded Deep Neural Network Processing: Algorithmic and Processor Techniques Bring Deep Learning to IoT and Edge Devices. IEEE Solid-State Circuits Magazine 9, 4 (2017), 55–65. https://doi.org/10.1109/MSSC.2017.2745818

    2017

  18. [26]

    Davis, Peter Y

    Erwei Wang, James J. Davis, Peter Y. K. Cheung, and George A. Constantinides

  19. [27]

    Pete Warden. 2018. Speech commands: A dataset for limited-vocabulary speech recognition. arXiv preprint arXiv:1804.03209 (2018)

    2018 arXiv

  20. [28]

    Yichi Zhang, Junhao Pan, Xinheng Liu, Hongzheng Chen, Deming Chen, and Zhiru Zhang. 2021. FracBNN: Accurate and FPGA-Efficient Binary Neural Networks with Fractional Activations. In The 2021 ACM/SIGDA International Symposium on Field-Programmable Gate Arrays (Virtual Event, US...

    2021

  21. [2019]

    In2019 IEEE 27th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM)

    LUTNet: Rethinking Inference in FPGA Soft Logic. In2019 IEEE 27th Annual International Symposium on Field-Programmable Custom Computing Machines (FCCM). 26–34. https://doi.org/10.1109/FCCM.2019.00014

    2019

  22. [2023]

    IEEE Transactions on Pattern Analysis and Machine Intelligence 45, 5 (2023), 6072–6085

    On the Convergence of Tsetlin Machines for the XOR Operator. IEEE Transactions on Pattern Analysis and Machine Intelligence 45, 5 (2023), 6072–6085. https://doi.org/10.1109/TPAMI.2022.3203150

    2023

Pith tools

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