A Blueprint for Precise and Fault-Tolerant Analog Neural Networks
Analog computing has reemerged as a promising avenue for accelerating deep
neural networks (DNNs) due to its potential to overcome the energy efficiency
and scalability challenges posed by traditional digital architectures. However,
achieving high precision and DNN accuracy using such technologies is
challenging, as high-precision data converters are costly and impractical. In
this paper, we address this challenge by using the residue number system (RNS).
RNS allows composing high-precision operations from multiple low-precision
operations, thereby eliminating the information loss caused by the limited
precision of the data converters. Our study demonstrates that analog
accelerators utilizing the RNS-based approach can achieve ${\geq}99\%$ of FP32
accuracy for state-of-the-art DNN inference using data converters with only
$6$-bit precision whereas a conventional analog core requires more than $8$-bit
precision to achieve the same accuracy in the same DNNs. The reduced precision
requirements imply that using RNS can reduce the energy consumption of analog
accelerators by several orders of magnitude while maintaining the same
throughput and precision. Our study extends this approach to DNN training,
where we can efficiently train DNNs using $7$-bit integer arithmetic while
achieving accuracy comparable to FP32 precision. Lastly, we present a
fault-tolerant dataflow using redundant RNS error-correcting codes to protect
the computation against noise and errors inherent within an analog accelerator.
Cansu Demirkiran, Lakshmi Nair, Darius Bunandar, Ajay Joshi
# A blueprint for precise and fault-tolerant analog neural networks

###### Abstract

Analog computing has reemerged as a promising avenue for accelerating deep neural networks (DNNs) due to its potential to overcome the energy efficiency and scalability challenges posed by traditional digital architectures. However, achieving high precision and DNN accuracy using such technologies is challenging, as high-precision data converters are costly and impractical. In this paper, we address this challenge by using the residue number system (RNS). RNS allows composing high-precision operations from multiple low-precision operations, thereby eliminating the information loss caused by the limited precision of the data converters. Our study demonstrates that analog accelerators utilizing the RNS-based approach can achieve \(\geq\)99% of FP32 accuracy for state-of-the-art DNN inference using data converters with only 6-bit precision whereas a conventional analog core requires more than 8-bit precision to achieve the same accuracy in the same DNNs. The reduced precision requirements imply that using RNS can reduce the energy consumption of analog accelerators by several orders of magnitude while maintaining the same throughput and precision. Our study extends this approach to DNN training, where we can efficiently train DNNs using 7-bit integer arithmetic while achieving accuracy comparable to FP32 precision. Lastly, we present a fault-tolerant dataflow using redundant RNS error-correcting codes to protect the computation against noise and errors inherent within an analog accelerator.

## Introduction

Deep Neural Networks (DNNs) are widely employed across various applications today. Unfortunately, their compute, memory, and communication demands are continuously on the rise. The slow-down in CMOS technology scaling, along with these increasing demands has led analog DNN accelerators to gain significant research interest. Recent research has been focused on using various analog technologies such as photonic cores [1; 2; 3; 4; 5; 6; 7], resistive arrays [8; 9; 10; 11; 12], switched capacitor arrays [13; 14], Phase Change Materials (PCM) [15], SpinTransfer Torque (STT)-RAM [16; 17], etc., to enable highly parallel, fast, and efficient matrix-vector multiplications (MVMs) in the analog domain. These MVMs are fundamental components used to build larger general matrix-matrix multiplication (GEMM) operations, which make up more than 90% of the operations in DNN inference and training [18].

The success of this approach, however, is constrained by the limited precision of the digital-to-analog and analog-to-digital data converters (i.e., DACs and ADCs). In an analog accelerator, the data is converted between analog and digital domains using data converters before and after every analog operation. Typically, a complete GEMM operation cannot be performed at once in the analog domain due to the fixed size of the analog core. Instead, the GEMM operation is tiled into smaller MVM operations. As a result, each MVM operation produces a partial output that must be accumulated with other partial outputs to obtain the final GEMM result. Concretely, an MVM operation consists of parallel dot products between \(b_{w}\)-bit signed weight vectors and \(b_{in}\)-bit signed input vectors--each with \(h\) elements--resulting in a partial output containing \(b_{\text{out}}\) bits of information, where \(b_{\text{out}}=b_{\text{in}}+b_{w}+\log_{2}(h)-1\). An ADC with a precision greater than \(b_{\text{out}}\) (i.e., \(b_{\text{ADC}}\geq b_{\text{out}}\)) is required to ensure no loss of information when capturing these partial outputs. Unfortunately, the energy consumption of ADCs increases exponentially with bit precision (often referred to as effective number of bits (ENOB)). This increase is roughly \(4\times\) for each additional output bit [19].

As a result, energy-efficient analog accelerator designs typically employ ADCs with lower precision than \(b_{\text{out}}\) and only capture the \(b_{\text{ADC}}\) most significant bits (MSBs) from the \(b_{\text{out}}\) bits of each partial output [20]. Reading only MSBs causes information loss in each partial output leading to accuracy degradation in DNNs, as pointed out by Rekhi et al. [20]. This degradation is most pronounced in large DNNs and large datasets. Fig. 1 shows the impact of this approach on DNN accuracy in two tasks: (1) a two-layer convolutional neural network (CNN) for classifying the MNIST dataset [21]: a simple task with only 10 classes, and (2) the ResNet50 CNN [22] for classifying the ImageNet dataset [23]: a more challenging task with 1000 classes. As the vector size \(h\) increases, higher precision is needed at the output to maintain the accuracy in both DNNs. Moreover, ResNet50 experiences accuracy degradation at smaller values of \(h\) compared to the two-layer CNN. While using a higher precision ADC can help recover from this accuracy degradation, it significantly reduces the energy efficiency of the analog hardware. Essentially, to efficiently execute large DNNs using analog accelerators, it is crucial to find a better way to achieve high accuracy than simply increasing the bit precision of
the data converters.

In this work, we present a universal residue number system (RNS)-based framework to overcome the above-mentioned challenge in analog DNN inference as well as DNN training. RNS represents high-precision values using multiple low-precision integer residues for a selected set of moduli. As such, RNS enables high-precision arithmetic without any information loss on the partial products, even when using low-precision DACs and ADCs. Utilization of RNS leads to a significant reduction in the data converter energy consumption, which is the primary contributor to energy usage in analog accelerators. This reduction can reach up to six orders of magnitude compared to a conventional fixed-point analog core with the same output bit precision.

Our study shows that the RNS-based approach enables \(\geq 99\%\) FP-32 inference accuracy by using only 6-bit data converters for state-of-the-art MLPerf (Inference: Datacenters) benchmarks [24] and Large Language Models (LLMs). We also demonstrate the applicability of this approach in training and fine-tuning state-of-the-art DNNs using low-precision analog hardware. The RNS approach, however, is susceptible to noise as small errors in the residues scale up during output reconstruction, leading to larger errors in the standard representation. To address this issue, we incorporate the Redundant RNS (RRNS) error-correcting code [25; 26; 27] to introduce fault-tolerance capabilities into the dataflow.

As RNS is closed under multiplication and addition, no significant changes are required in the design of the analog core or in how GEMM operations are performed. Unlike a conventional analog core design, performing RNS operations necessitates an analog modulo operation. This operation can be implemented by using ring oscillators [28] in an analog electrical core or by using optical phase shifters in an analog optical core. Our proposed framework, however, remains agnostic to the underlying technology. Importantly, arbitrary fixed-point precision can be achieved by combining the positional number system (PNS) and RNS in analog hardware. Overall, our presented RNS-based methodology offers a solution combining high accuracy, high energy efficiency, and fault tolerance in analog DNN inference and training.

## Results

### DNN Inference and Training Using RNS

The RNS represents an integer as a set of smaller (integer) residues. These residues are calculated by performing a modulo operation on the said integer using a selected set of \(n\)_co-prime_ moduli. Let \(A\) be an integer. \(A\) can be represented in the RNS with \(n\) residues as \(\{a_{1},\ldots,a_{n}\}\) for a set of co-prime moduli \(\mathcal{M}=\{m_{1},\ldots,m_{n}\}\) where \(a_{i}=|A|_{m_{i}}\equiv A\mod m_{i}\) for \(i\in\{1\ldots n\}\). \(A\) can be uniquely reconstructed using the Chinese Remainder Theorem (CRT):

\[A=\bigg{|}\sum_{i=1}^{n}a_{i}M_{i}T_{i}\bigg{|}_{M}, \tag{1}\]

if \(A\) is within the range \([0,M)\) where \(M=\prod_{i}m_{i}\). Here, \(M_{i}=M/m_{i}\) and \(T_{i}\) is the multiplicative inverse of \(M_{i}\), i.e., \(|M_{i}T_{i}|_{m_{i}}\equiv 1\). Hereinafter, we refer to the integer \(A\) as the _standard representation_, while we refer to the set of integers \(\{a_{1},\ldots,a_{n}\}\) simply as the residues.

A DNN consists of a sequence of \(L\) layers. During inference, where the DNN is previously trained and its parameters are fixed, only a forward pass is performed. Generically, the input \(X\) to \((\ell+1)\)-th layer of a DNN during the forward pass is the output generated by the previous \(\ell\)-th layer:

\[X^{(\ell+1)}=f^{(\ell)}\big{(}W^{(\ell)}X^{(\ell)}\big{)}, \tag{2}\]

where \(W^{(\ell)}X^{(\ell)}=O^{(\ell)}\) is a GEMM operation and \(f(\cdot)\) is an element-wise nonlinear function.

DNN training requires both forward and backward passes as well as weight updates. The forward pass in the training is performed the same way as in Eq. (2). After the forward pass, a loss value \(\mathcal{L}\) is calculated using the output of the last layer and the ground truth. The gradients of the DNN activations and parameters with respect to \(\mathcal{L}\) for each layer are calculated by performing a backward pass after each forward pass:

\[\frac{\partial\mathcal{L}}{\partial X^{(\ell)}}={W^{(\ell)}}^{T}\frac{\partial \mathcal{L}}{\partial O^{(\ell)}}, \tag{3}\]

\[\frac{\partial\mathcal{L}}{\partial W^{(\ell)}}=\frac{\partial\mathcal{L}}{ \partial O^{(\ell)}}{X^{(\ell)}}^{T}. \tag{4}\]

Figure 1: **Inference accuracy versus vector size for varying data bit-width in a conventional analog core.****a** Inference accuracy for a two-layer CNN classifying handwritten digits from the MNIST dataset. **b** Inference accuracy for ResNet50 classifying images from the ImageNet dataset evaluated in an analog core with varying precision \(b\) and vector sizes \(h\). For both **a** and **b**, **b**-bit precision means \(b=b_{\text{DAC}}=b_{\text{ADC}}<b_{\text{out}}\) where \(b\) varies between 2 and 8.
Using these gradients \(\Delta W^{(\ell)}=\frac{\partial\mathcal{L}}{\partial W^{(\ell)}}\), the DNN parameters are updated in each iteration \(i\):

\[W^{(\ell)}_{i+1}=W^{(\ell)}_{i}-\eta\Delta W^{(\ell)}_{i} \tag{5}\]

with a step size \(\eta\) for a simple stochastic gradient descent (SGD) optimization algorithm.

Essentially, for each layer, one GEMM operation is performed in the forward pass and two GEMM operations are performed in the backward pass. Because RNS is closed under addition and multiplication operations, GEMM operations can be performed in the RNS space. Using the RNS, Eq. (2) can be rewritten as:

\[X^{(\ell+1)}=f^{(\ell)}\Bigg{(}\text{CRT}\bigg{(}\Big{|}\big{|}W^{(\ell)}\big{|} _{\mathcal{M}}\big{|}X^{(\ell)}\big{|}_{\mathcal{M}}\Big{|}_{\mathcal{M}} \bigg{)}\Bigg{)}. \tag{6}\]

The same approach applies for Eqs. (3) and (4) in the backward pass.

The moduli set \(\mathcal{M}\) must be chosen to ensure that the outputs of the RNS operations are smaller than \(M\), which means that

\[\log_{2}M\geq b_{\text{out}}=b_{\text{in}}+b_{w}+\log_{2}(h)-1, \tag{7}\]

should be guaranteed for a dot product between \(b_{\text{in}}\)-bit input and \(b_{w}\)-bit weight vectors with \(h\)-elements. This constraint prevents overflow in the computation.

### Precision and Energy Efficiency in the RNS-based Analog Core

The selection of moduli set \(\mathcal{M}\), which is constrained by Eq. (7), impacts the achievable precision at the output as well as the energy efficiency of the RNS-based analog core. Table 1 compares RNS-based analog GEMM cores with example moduli sets and regular fixed-point analog GEMM cores. Here, we show two cases for the regular fixed-point representation: (1) the low-precision (LP) case where \(b_{\text{out}}>b_{\text{ADC}}=b_{\text{DAC}}\), and (2) the high-precision (HP) case where \(b_{\text{out}}=b_{\text{ADC}}>b_{\text{DAC}}\). It should be noted that all three analog cores represent data as fixed-point numbers. We use the term'regular fixed-point core' to refer to a typical analog core that performs computations in the standard representation (without RNS). 'RNS-based core' refers to an analog core that performs computations on the fixed-point residues.

While the LP approach introduces \(b_{\text{out}}-b_{\text{ADC}}\) bits of information loss in every dot product, the HP approach uses high-precision ADCs to prevent this loss. For the RNS-based core, we picked \(b_{\text{in}}=b_{w}=b_{\text{ADC}}=b_{\text{DAC}}=\lceil\log_{2}m_{i}\rceil \equiv b\) for ease of comparison against the fixed-point cores. Table 1 shows example moduli sets that are chosen to guarantee Eq. (7) for \(h=128\) while keeping the moduli under the chosen bit-width \(b\). In this case, for \(n\) moduli with bit-width of \(b\), \(M\) covers \(\approx n\cdot b\) bits of range at the output. \(h\) is chosen to be 128 as an example considering the common layer sizes in the evaluated MLPerf (Inference: Datacenter) benchmarks. The chosen \(h\) provides high throughput with high utilization of the GEMM core.

Fig. 2a compares the error (with respect to FP32 results) observed when performing dot products with the RNS-based core and the LP fixed-point core with the same bit precision. Both cores use the configurations described in Table 1 for the example vector size \(h=128\). The larger absolute error observed in the LP fixed-point case illustrates the effect of the information loss mentioned above. HP fixed-point case is not shown as it is equivalent to the RNS case.

Fig. 2b shows the energy consumption of DACs and ADCs per dot product for the three aforementioned analog hardware configurations. To achieve the same MVM throughput as the (LP/HP) fixed-point cores, the RNS-based core with \(n\) moduli must use \(n\) distinct MVM units and \(n\) sets of DACs and ADCs. This makes the energy consumption of the RNS-based core \(n\times\) larger compared to the LP fixed-point approach. However, the LP fixed-point approach with low-precision ADCs experiences information loss in the partial outputs and hence has lower accuracy.

The RNS-based approach and the HP fixed-point approach provide the same bit precision (i.e., the same DNN accuracy). Yet, using the RNS-based approach is orders of magnitude more energy-efficient than the HP fixed-point approach. This is mainly because of the high cost of high-precision ADCs required to capture the full output in the HP fixed-point approach. ADCs dominate the energy consumption with approximately three orders of magnitude higher energy usage than DACs with the same bit precision. In addition, energy consumption in ADCs increases exponentially with increasing bit precision[19]. This favors using multiple DACs and ADCs with lower precision in the RNS-based approach over using a single high-precision ADC. Briefly, the RNS-based approach provides a sweet spot between LP and HP fixed-point approaches without compromising on both high accuracy and high energy efficiency.

### Accuracy in the RNS-based Analog Core

Fig. 3a compares the inference accuracy of MLPerf (Inference: Datacenters) benchmarks[24] and OPT[29] (a transformer-based LLM) when run on an RNS-based analog core and a fixed-point (LP) analog core. The HP fixed-point analog core results are not shown as they are equivalent to the RNS-based results. The evaluated DNNs, their corresponding tasks, and the datasets are listed in Table 2. Fig. 3a shows that the RNS-based approach significantly ameliorates the accuracy drop caused by the low-precision ADCs used in the LP fixed-point approach for all the networks. By using the RNS-based approach, it is possible to achieve \(\geq\)99% of FP32 accuracy (this cut-off is defined in the MLPerf benchmarks[24]) for all evaluated benchmarks when using residues with as
low as 6 bits. This number can be lowered to 5 bits for BERT-large and RNN-T and to 4 bits for DLRM.

Besides inference, the RNS-based approach opens the door for analog computing to be used in tasks that require higher precision than inference such as DNN training. Figure 3b shows the loss during DNN training/fine-tuning. Table 3 reports the validation accuracies after FP32 and RNS-based low-precision training. Here, the GEMM operations during forward and backward passes of training follow the same methodology as inference, with weight updates carried out in FP32. Our experiments show that \(\geq\)99% FP32 validation accuracy is achievable after training ResNet50 from scratch using the RNS-based approach with only 6-bit moduli. Similarly, fine-tuning BERT-large and OPT-125M by using 5-bit and 7-bit moduli, respectively, can reach \(\geq\)99% FP32 validation accuracy. The results are noticeably promising as the previous efforts on analog DNN hardware that adopted the LP fixed-point approach had never successfully demonstrated the training of state-of-the-art DNNs due to the limited precision of this approach.

Fig. 4 illustrates the dataflow of the RNS-based analog core when performing MVM as part of the DNN inference/training. An input vector \(X\) and a weight matrix \(W\) to be multiplied in the MVM unit are first mapped to signed integers. To mitigate the quantization effects, \(X\) and each row in \(W\) are scaled by an FP32 scaling factor that is unique to the vector (See Methods). The signed integers are then converted into RNS residues through modulo operation (i.e., forward conversion). By construction, each residue is within the range of \([0,m_{i})\). To achieve the same throughput as a fixed-point analog core, the RNS-based analog core with \(n\) moduli requires using \(n\) analog MVM units--one for each modulus--and running them in parallel. Each analog MVM unit requires a set of DACs for converting the associated input and weight residues into the analog domain. The MVM operations are followed by an analog modulo operation on each output residue vector. Thanks to the modulo operation, the output residues--to be captured by ADCs--are reduced back to the \([0,m_{i})\) range. Therefore, a bit precision of \([\log_{2}m_{i}]\) is adequate for both DACs and ADCs to perform input and output conversions without any information loss. The output residues are then converted back to the standard representation in the digital domain using Eq. (1) to generate the signed-integer output vector, which is then mapped back to an FP32 final output \(Y\). The non-linear function \(f\) (e.g., ReLU, sigmoid, etc.) is then performed digitally in FP32.

\begin{table}
\begin{tabular}{l l l} \hline \hline
**DNN** & **Task** & **Dataset** \\ \hline ResNet50 & Image classification & ImageNet[23] \\ SSD-ResNet34 & Object detection & MS COCO[35] \\ BERT-Large & Question answering & SQuADv1.[13] \\ RNN-T & Speech recognition & Librispeech[37] \\ DLRM & Recommendation & 1TB Click Logs[38] \\ OPT-125M & Language Modeling & Wikitext[39] \\ OPT-350M & Language Modeling & Wikitext[39] \\ \hline \hline \end{tabular}
\end{table}
Table 2: MLP Perf (Inference: Datacenters) benchmarks.

\begin{table}
\begin{tabular}{c c c c c c c c c c c c} \hline \hline  & \multicolumn{4}{c}{**RNS-based Core (This work)**} & \multicolumn{4}{c}{**LP Fixed-Point Core**} & \multicolumn{4}{c}{**HP Fixed-Point Core**} \\ \cline{3-10} \(b_{\text{in}}\), \(b_{w}\) & \(b_{\text{DAC}}\) & \(\log_{2}\)\(\mathcal{M}\) & \(b_{\text{ADC}}\) & Moduli Set (\(\mathcal{M}\)) & RNS Range (\(M\)) & \(b_{\text{DAC}}\) & \(b_{\text{out}}\) & \(b_{\text{ADC}}\) & Lost Bits & \(b_{\text{DAC}}\) & \(b_{\text{out}}\) & \(b_{\text{ADC}}\) \\ \hline
4 & 4 & 4 & 4 & 4 & \(\{15,14,13,11\}\) & \(\simeq 2^{15}-1\) & 4 & 14 & 4 & 10 & 4 & 14 & 14 \\
5 & 5 & 5 & 5 & 5 & \(\{31,29,28,27\}\) & \(\simeq 2^{19}-1\) & 5 & 16 & 5 & 11 & 5 & 16 & 16 \\
6 & 6 & 6 & 6 & 6 & \(\{63,62,61,59\}\) & \(\simeq 2^{24}-1\) & 6 & 18 & 6 & 12 & 6 & 18 & 18 \\
7 & 7 & 7 & 7 & 7 & \(\{127,126,125\}\) & \(\simeq 2^{21}-1\) & 7 & 20 & 7 & 13 & 7 & 20 & 20 \\
8 & 8 & 8 & 8 & \(\{255,254,253\}\) & \(\simeq 2^{24}-1\) & 8 & 22 & 8 & 14 & 8 & 22 & 22 \\ \hline \hline \end{tabular}
\end{table}
Table 1: Data and data converter precision in RNS-based, LP fixed-point, and HP fixed-point analog cores.

Figure 2: **Comparison of the RNS-based and regular fixed-point analog approaches.** The distribution of average error observed at the output of a dot product performed with the RNS-based analog approach (pink) and the LP regular fixed-point analog approach (cyan). Error is defined as the distance from the result calculated in FP32. The experiments are repeated for 10,000 randomly generated vector pairs with vector size \(h=128\). **b** Energy consumption of data converters (i.e., DACs and ADCs) per dot product for the RNS-based analog approach (pink) and the LP (cyan) and HP (dark blue) regular fixed-point analog approaches. See Methods for the energy estimation methodology.
### Redundant RNS for Fault Tolerance

Analog compute cores are sensitive to noise. In the case of RNS, even small errors in the residues can result in a large error in the corresponding integer they represent. The Redundant Residue Number System (RRNS) [25; 26; 27] can detect and correct errors--making the RNS-based analog core fault tolerant. RRNS uses a total of \(n+k\) moduli: \(n\) non-redundant and \(k\) redundant. An RRNS(\(n+k,n\)) code can detect up to \(k\) errors and can correct up to \(\lfloor\frac{k}{2}\rfloor\) errors. In particular, the error in the codeword (i.e., the \(n+k\) residues representing an integer in the RRNS space) can be one of the following cases:

* **Case 1:** Fewer than \(\lfloor\frac{k}{2}\rfloor\) residues have errors--thereby they are correctable,
* **Case 2:** Between \(\lfloor\frac{k}{2}\rfloor\) and \(k\) residues have errors or the codeword with more than \(k\) errors does not overlap with another codeword in the RRNS space--thereby the error is detectable,
* **Case 3:** More than \(k\) residues have errors and the erroneous codeword overlaps with another codeword in the RRNS space--thereby the error goes undetected.

Errors are detected by using majority logic decoding wherein we divide the total \(n+k\) output residues into

Figure 4: **RNS-based analog GEMM dataflow. The operation is shown for a moduli set \(\mathcal{M}=\{m_{1},\dots,m_{n}\}\). The \(n\times h\) analog MVM units are represented as generic blocks. The dataflow is agnostic of the technology.**

Figure 3: **Accuracy performance of the RNS-based analog core.****a Inference accuracy of regular fixed-point (LP) and RNS-based cores (See Table 1) on MLPer (Inference: Datacenters) benchmarks. The accuracy numbers are normalized to the FP32 accuracy. b-d Loss during training for FP32 and RNS-based approaches with varying moduli bit-width. ResNet50 (a) is trained from scratch for 90 epochs using SGD optimizer with a momentum. BERT-Large (b) and OPT-125M (c) are fine-tuned from pre-trained models. Both models are fine-tuned using the Adam optimizer with a linear learning rate scheduler for 2 and 3 epochs for BERT-Large and OPT-125M, respectively. All inference and training experiments use FP32 for all non-GEMM operations.**
\(\binom{n+k}{n}\) groups with \(n\) residues per group. One simple way of majority logic decoding in this context is to convert the residues in each group back to the standard representation via CRT to generate an output value for each group and compare the results of the \(\binom{n+k}{n}\) groups. If more than 50% of the groups have the same result in the standard representation, then the generated codeword is correct. This corresponds to **Case 1**. In contrast, not having a majority indicates that the generated codeword is erroneous and cannot be corrected. This corresponds to **Case 2**. In this case, the detected errors can be eliminated by repeating the entire calculation. In **Case 3**, the erroneous codeword generated by the majority of the groups overlaps with another codeword. As a result, more than 50% of the groups have the same incorrect result and the error goes undetected. To optimize the hardware performance of this process, more efficient base-extension-based algorithms [30] instead of CRT can be used for error detection.

The final error probability in an RRNS code depends on the percentage of the _non-correctable_ errors observed in the residues. This probability is influenced by the chosen moduli set and the number of error correction iterations (See Methods). Let \(p_{c},p_{d}\), and \(p_{u}\) be the probabilities that Cases 1, 2, and 3 occur respectively when computing a single output. Overall, \(p_{c}+p_{d}+p_{u}=1\). For a single attempt (i.e., \(R=1\)), the probability of producing the incorrect output integer is \(p_{\text{err}}(R=1)=1-p_{c}=p_{u}+p_{d}\). Generally, it is possible to repeat the calculations \(R\)-times until no detectable error is found at the expense of increasing compute latency. In this case, the probability of having an incorrect output after \(R\) attempts of error correction is

\[p_{\text{err}}(R)=1-p_{c}\sum_{r=0}^{R-1}(p_{d})^{r}. \tag{8}\]

As the number of attempts increases, the output error probability decreases and converges to \(\lim_{R\rightarrow\infty}p_{\text{err}}(R)=p_{u}/(p_{u}+p_{c})\).

Fig. 5 shows \(p_{\text{err}}\) for different numbers of redundant moduli (\(k\)), attempts (\(R\)), and moduli sets with different bit-widths. Broadly, as the probability of a single residue error \(p\) increases, the output error probability tends to 1. For a given number of attempts, increasing bit precision and the number of redundant moduli decreases \(p_{\text{err}}\). For a fixed number of redundant moduli and a fixed number of bits per moduli, \(p_{\text{err}}\) decreases as the number of attempts increases.

Fig. 6 investigates the impact of noise on the accuracy of two large and important MLPerf benchmarks--ResNet50 and BERT-Large--when using RRNS. The two networks show similar behavior: adding extra moduli and increasing the number of attempts decrease \(p_{\text{err}}\) at the same value of \(p\). ResNet50 requires \(\sim\)3.9 GigaMAC operations (GOp) for one inference on a single input image. For a \(128\times 128\) MVM unit, inferring an ImageNet image through the entire network involves computing \(\sim\)29.4M partial output elements. Therefore, we expect the transition point from an accurate network to an inaccurate network to occur at \(p_{\text{err}}\) to be \(\leq 1/29.4\text{M}=3.4\times 10^{-8}\). This \(p_{\text{err}}\) transition point is \(\leq 1/358.6\text{M}=2.8\times 10^{-9}\) for BERT-Large. Fig. 6, however, shows that the evaluated DNNs are more resilient to noise than expected: it is able to tolerate higher \(p_{\text{err}}\) while maintaining good accuracy. The accuracy of ResNet50 only starts degrading (below 99% FP32) when \(p_{\text{err}}\approx 4.5\times 10^{-5}\) (1000\(\times\) higher than the estimated value) on average amongst the experiments shown in Figure 6. This transition probability is \(p_{\text{err}}\approx 4\times 10^{-4}\) for BERT-Large (on average \(100,000\times\) higher than the estimated value).

## Discussion

The RNS (and the fault-tolerant RRNS) framework are agnostic to the analog technology employed. Generally, the RNS GEMM operations can be performed as a regular GEMM operation followed by a modulo operation in the analog domain. Analog GEMM is well-explored in the literature. Previous works leveraged photonics [1; 2; 3; 4; 5; 6; 7], crossbar arrays consisting of resistive RAM [8; 9; 10; 11; 12], switched capacitors [13; 14], PCM cells [15], STT-RAM [16; 17], etc.

The analog modulo operation can be performed electrically or optically. In the electronic domain, one can use ring oscillators: a circuit that generates a continuous waveform by cycling through a series of inverters [28] to perform modulo operations. By carefully designing the parameters of the ring oscillator, it is possible to create an output frequency that corresponds to the desired modulus value. Alternatively, the phase of a signal can be used for performing modulo due to the periodicity of phases in optical systems. Optical phase is inherently modular against \(2\pi\). By modulating the phase of an optical signal, one can achieve modulo operations in the analog domain. Using RNS requires forward and reverse conversion circuits to switch between the RNS and the standard number system. The forward conversion is a modulo operation while the reverse conversion can be done using the CRT, mixed-radix conversion, or look-up tables. The (digital) hardware costs of these circuits can be reduced by choosing special moduli sets [31; 32].

The RNS framework can be extended with the PNS to

\begin{table}
\begin{tabular}{l c c c} \hline \hline
**Precision** & **ResNet50** & **BERT-Large** & **OPT-125M** \\
**Acc.(\%)** & **F1 Score (\%)** & **Acc.(\%)/PPL** \\ \hline FP32 & 75.80 & 91.03 & 43.95/19.72 \\
8-bit & 75.77 & 90.98 & 43.86/20.00 \\
7-bit & 75.68 & 90.97 & 43.59/20.71 \\
6-bit & 75.13 & 90.85 & 42.79/22.62 \\
5-bit & 59.72 & 90.81 & 41.45/26.17 \\
4-bit & 42.15 & 89.66 & 38.64/35.65 \\ \hline \hline \end{tabular}
\end{table}
Table 3: Validation accuracy results after training/fine-tuning.
work with arbitrary precision, despite having DACs and ADCs with limited precision. For applications requiring higher-precision arithmetic than the example cases in this study (e.g., some high-performance computing applications, homomorphic encryption, etc.), a higher \(M\) value and therefore moduli with higher bit-width might be necessary, which will be bound by the same limitations discussed in this paper. Instead, one can represent an integer value as \(D\) separate digits where each digit is represented as a set of residues in the RNS domain and has an RNS range of \(M\). This hybrid scheme can achieve \(D\log_{2}M\) bit precision where \(D\) can liberally be increased without increasing the bit precision of the data converters. Different from the RNS-only scheme, the hybrid scheme requires overflow detection and carry propagation from lower digits to higher digits. The overflow detection can be achieved using two sets of residues: primary and secondary. While the operations are performed with both sets of residues, base extension between two sets helps detect any overflow and propagate the carry to the higher digits if required (See Methods).

In conclusion, our work provides a methodology for precise, energy-efficient, and fault-tolerant analog DNN acceleration. Overall, we believe that RNS is a crucial numeral system for the development of next-generation analog hardware capable of both inference and training state-of-the-art neural networks for advanced applications, such as generative artificial intelligence.

## Methods

### Handling Negative Numbers with RNS

An RNS with dynamic range \(M\) allows representing values within the range of \([0,M)\). This range can be shifted to \([-\psi,\psi]\), where \(\psi=[(M-1)/2]\), to represent negative values. This is achieved by reassigning the values in between \((0,\phi]\) to be positive, \(0\) to be zero, and the numbers in between \((\psi,2\psi]\) to be negative (i.e. \([-\psi,0]\)). Then, the values can

Figure 5: **Calculated output error probability (\(\mathbf{p}_{err}\)) versus single residue error probability (\(\mathbf{p}\)). a-c \(p_{err}\) for one (a), two (b), and infinite (c) error correction attempts and a varying number of redundant moduli (\(k\)).**

Figure 6: **Inference accuracy versus single residue error probability (\(\mathbf{p}\)). a-f The plots show ResNet-50 (a-c) and BERT-Large (d-f) inference accuracy results under varying \(p\) for one (a and d), two (b and e), and infinite (e and f) error correction attempts and a varying number of redundant moduli (\(k\)).**
be recovered uniquely by using CRT with a slight modification:

\[A=\begin{cases}\sum\limits_{l=1}^{n}|a_{i}M_{i}T_{i}|_{M},&\text{if }\sum\limits_{i=1}^{n}|a_{i}M_{i}T_{i}|_{M}\leq\psi\\ \sum\limits_{i=1}^{n}|a_{i}M_{i}T_{i}|_{M}-M,&\text{otherwise}.\end{cases} \tag{9}\]

### Data Converter Energy Estimation

The DAC and ADC energy numbers in Fig. 2**(b)** are estimated by using equations formulated by Murmann [19; 33]. The energy consumption of a DAC per conversion is

\[E_{\text{DAC}}=\text{ENOB}^{2}C_{u}V_{\text{DD}}^{2}, \tag{10}\]

where \(C_{u}=0.5\) fF is a typical unit capacitance and \(V_{\text{DD}}=\) 1V is the supply voltage [19]. The energy consumption of an ADC per conversion is estimated as

\[E_{\text{ADC}}=k_{1}\text{ENOB}+k_{2}4^{\text{ENOB}}, \tag{11}\]

where \(k_{1}\)\(\approx\)100 fJ and \(k_{2}\)\(\approx\)1 aJ. \(E_{\text{ADC}}\) is dominated by the exponential term (i.e., \(k_{2}4^{\text{ENOB}}\)) at large ENOB ( \(\geq\) 10-bits).

### Accuracy Modeling

Both RNS-based and regular fixed-point analog cores are modeled using PyTorch for estimating inference and training accuracy. Convolution, linear, and hatched matrix multiplication (BMM) layers are performed as tiled-GEMM operations which are computed tile-by-tile as a set of tiled-MVM operations. Each input, weight, and output of the tiled MVM are quantized with a desired bit precision.

Pre-quantization, the input vectors and weight tiles are first dynamically scaled, i.e. scaled at runtime, to mitigate the quantization effects as follows: For an \(h\times h\) weight tile \(\mathcal{W}_{t}\), we denote each row vector as \(\mathcal{W}_{t}\) where the subscript \(r\) stands for the row and \(t\) for the tile. Similarly, an input vector of length \(h\) is denoted as \(\mathcal{X}_{t}\) where tiledinates the tile. Each weight row \(\mathcal{W}_{t}\) shares a single FP32 scale \(s^{r}_{rt}=\max(|\mathcal{W}_{rt}|)\) and each input vector \(\mathcal{X}_{t}\) shares a single FP32 scale \(s^{r}_{rt}=\max(|\mathcal{X}_{t}|)\). \(h\) scales per \(h\times h\) weight tile and 1 scale per input vector, in total \(h+1\) scales, are stored for each tiled-MVM operation. The tiled MVM is performed between the scaled weight and input vectors, \(\mathcal{W}_{rt}=\mathcal{W}_{rt}/s^{r}_{rt}\) and \(\mathcal{\widetilde{X}}_{t}=\mathcal{X}_{t}/s^{r}_{rt}\), to produce \(\mathcal{\widetilde{Y}}_{t}=\mathcal{\widetilde{W}}_{t}\mathcal{\widetilde{X} }_{t}\). The output \(\mathcal{\widetilde{Y}}_{rt}\) is then quantized (if required) to resemble the output ADCs and multiplied back with the appropriate scales so that the actual output elements \(Y_{rt}=\mathcal{\widetilde{Y}}_{rt}\cdot s^{r}_{rt}\) are obtained.

Here, the methodology is the same for RNS-based and regular fixed-point cores. For the RNS-based case, in addition to the description above, the quantized input and weight integers are converted into the RNS space before the tiled-MVM operations. MVMs are performed separately for each set of residues and are followed by a modulo operation before the quantization step. The output resides for each tiled MVM are converted back to the standard representation using the CRT.

The GEMM operations (i.e., convolution, linear, and RBM layers) are sandwiched between input operation \(O_{\text{m}}\) and an output operation \(O_{\text{out}}\). This makes the operation order \(O_{\text{in}}\)-GEMM-\(O_{\text{out}}\) during the forward pass, and \(O_{\text{out}}\)-GEMM-\(O_{\text{in}}\) in the backward pass. On i.e. times the input and weight tensors the forward pass and is a null operation in the backward pass. In contrast, \(O_{\text{out}}\) is a null operation in the forward pass and quantizes the activation gradients in the backward pass. In this way, the quantization is always performed before the GEMM operation. The optimizer (i.e., SGD or Adam) is modified to keep a copy of the FP32 weights to use during the weight updates. Before each forward pass, the FP32 weights are copied and stored. After the forward pass, the quantized model weights are replaced by the previously stored FP32 weights before the step function so that the weight updates are performed in FP32. After the weight update, the model parameters are quantized again for the next forward pass. This high-precision weight update step is crucial for achieving high accuracy in training.

In Fig. 3b, all the convolution, linear, and BMM layers in the models were replaced by the quantized versions. We trained ResNet50 from scratch by using SGD optimizer for 90 epochs with a momentum of 0.9 and a learning rate starting from 0.1. The learning rate was scaled down by 10 at epochs 30, 60, and 80. We fine-tuned BERT-large and OPT-125M from the implementations available in the Hugging-face transformers repository [34]. We used the Adam optimizer for both models with the default settings. The script uses a linear learning rate scheduler. The learning rate starts at 3e-05 and 5e-05 and the models are trained for 2 and 3 epochs, respectively for BERT-Large and OPT-125M.

### Error distribution in the RRNS code space

For an \(\text{RRNS}(n+k,n)\) with \(n\) non-redundant moduli \((m_{1},m_{2},...,m_{n})\) and \(k\) redundant moduli \((m_{n+1},m_{n+2},...,m_{n+k})\), the probability distributions \((p_{x},\ p_{d},\) and \(p_{u})\) of different types of errors (Case 1, Case 2, and Case 3 that were mentioned in Redundant RNS for Fault Tolerance) are related to the Hamming distance distribution of the RRNS code space. In an \(\text{RRNS}(n+k,n)\), every integer is represented as \(n+k\) residues (\(r_{i}\) where \(i\in\{1,...,n+k\}\)) and this vector of \(n+k\) residues is considered as an RRNS codeword. A Hamming distance of \(q\in\{0,1,...,n+k\}\) between the original codeword and the erroneous codeword indicates that \(n\) out of \(n+k\) residues are erroneous. The erroneous codewords create a new vector space of \(n+k\)-long vectors where at least one \(r_{i}\) is replaced with \(r^{\prime}_{i}\neq r_{i}\) with \(i\in\{1,...,n+k\}\) and \(r^{\prime}_{i}<m_{i}\). This vector space includes all the \(\text{RRNS}(n+k,n)\) codewords as well as other possible \(n+k\)-long vectors that do not overlap with any codeword in the RRNS code space space. A vector represents a codeword and is in the RRNS code space if and only if it can be converted into a value within the legitimate range \([0,M)\) of the \(\text{RRNS}(n+k,n)\) by using the CRT. The number of all vectors that have a Hamming distance \(\eta\) from a codeword in \(\text{RRNS}(n+k,n)\) can be expressed as

\[V_{\eta}=\sum\limits_{Q\binom{n+k}{\eta}}\prod\limits_{i=1}^{\eta}(m_{i}-1), \tag{12}\]

where \(Q\binom{n+k}{\eta}\) represents one selection of \(\eta\) moduli from \(n+k\) moduli while \(\sum_{Q\binom{n+k}{\eta}}\) represents the summation over all distinct \(\binom{n+k}{\eta}\) selections. The number of codewords that are in the RNS code space with a Hamming distance of \(\eta\in\{0,1,...,n+k\}\) can be expressed as

\[\centering\mathcal{D}_{\eta}=\sum\limits_{h=0}^{\eta-1-k}(-1)^{h}\binom{n+k-\eta +h}{n+k-\eta}\zeta(n+k,\eta-h),\@add@centering \tag{13}\]

for \(k+1\leq\eta\leq n+k\). For \(1\leq\eta\leq k\), \(D_{\eta}=0\) and \(D_{0}=1\). \(\zeta(n+k,\eta)\) represents the total number of non-zero common divisors in the height range \([0,M)\) for any \(n+k-\eta\) moduli out of the \(n+k\) moduli of the \(\text{RRNS}(n+k,n)\) code and can be denoted as

\[\centering\zeta(n+k,\eta)=\sum\limits_{Q\binom{n+k}{\eta+k-\eta}}\left\lfloor \frac{M-1}{m_{i_{1}}m_{i_{2}}...m_{i_{n+k-\eta}}}\right\rfloor,\@add@centering \tag{14}\]

where \((m_{i_{1}},m_{i_{2}},...,m_{i_{\lambda}})\) with \(1\leq\lambda\leq n+k\) is a subset of the \(\text{RRNS}(n+k,n)\) moduli set.

An undetectable error occurs only if a codeword with errors overlaps with another codeword in the same RRNS space. Given the distance distributions for the vector space \(V\) and the codespace \(D\) (Eq. (12), (13), respectively), the probability of observing an undetectable error \((p_{u})\) for \(\text{RRNS}(n+k,n)\) can be computed as

\[\centering p_{u}=\sum\limits_{\eta=k+1}^{n+k}\frac{D_{\eta}}{V_{\eta}}p_{E}( \eta),\@add@centering \tag{15}\]

where \(p_{E}(\eta)\) is the probability of having \(\eta\) erroneous residues in a codeword which can be calculated as

\[\centering p_{E}(\eta)=\sum\limits_{Q\binom{n+k}{\eta}}p^{\eta}(1-p)^{(n+k-\eta )},\@add@centering \tag{16}\]

for an error probability of \(p\) in a single residue.

Eq. (13) indicates that for up to \(\eta=k\) erroneous residues \(D_{\eta}=0\), and so it is not possible for an erroneous codeword to overlap with
another codeword in the RRNS code space. This guarantees the successful detection of the observed error. If the Hamming distance of the erroneous codeword is \(\eta\leq\lfloor\frac{k}{2}\rfloor\), the error can be corrected by the majority logic decoding mechanism. In other words, the probability of observing a correctable error is equal to observing less or equal to \(\lfloor\frac{k}{2}\rfloor\) errors in the residues and can be calculated as

\[p_{c}=\sum_{\eta=0}^{\lfloor\frac{k}{2}\rfloor}p_{E}(\eta)=\sum_{\eta=0}^{ \lfloor\frac{k}{2}\rfloor}\Big{(}\sum_{Q\binom{(n+k)}{\eta}}p^{\eta}(1-p)^{(n+k -\eta)}\Big{)}. \tag{17}\]

All the errors that do not fall under the undetectable or correctable categories are referred to as detectable but not correctable errors with a probability \(p_{d}\) where \(p_{d}=1-(p_{c}+p_{d})\). The equations in this section were obtained from the work conducted by Yang [27].

To model the error in the RNS core for the analysis shown in Fig. 6, \(p_{c}\), \(p_{d}\), and \(p_{u}\) are computed for a given RNS\((n+k,n)\) using Eqs. (15) and (17). Given the number of error correction attempts, output error probability (\(p_{err}\)) is calculated according to Eq. (8). Random noise is injected at the output of every tiled-MVM operation using a Bernoulli distribution with the probability of \(p_{err}\).

## RNS Operations

The proposed analog RNS-based approach requires modular arithmetic. In this section, we discuss two ways of performing modular arithmetic in the analog domain, one electrical and one optical.

### Modular Arithmetic with Ring Oscillators

In a ring oscillator, where each inverter has a propagation delay \(t_{\rm prop}>0\), there is always only one inverter that has the same input and output--either 1-1 or 0-0--at any given time when the ring oscillator is on. The location of this inverter with the same input and output propagates along with the signal every \(t_{\rm prop}\) time and rotates due to the ring structure. This rotation forms a modulator behavior in the ring when the location of this inverter is tracked.

Let \(S_{\rm RO}(t)\) be the state of a ring oscillator with \(N\) inverters. Here, \(S_{\rm RO}(t)\in\{0,...,N-1\}\) and \(S_{\rm RO}(t)=k\) means that the \(k+1\)-th inverter's input and output have the same value at time \(t\). \(S_{\rm RO}(t)\) keeps rotating between 0 to \(N-1\) as long as the oscillator is on. Figure 7a shows a simple example where \(N=3\). In the first \(t_{\rm prop}\) time interval, the input and output the first inverter are both 0, therefore, the state \(S_{\rm RO}(t<t_{\rm prop})=0\). Similarly, when \(t_{\rm prop}<t<2t_{\rm prop}\), the input and output of the second inverter are 1, so \(S_{\rm RO}(t_{\rm prop}<t<2t_{\rm prop})=1\). Here, the time between two states following one another (i.e., \(t_{\rm prop}\)) is fixed as \(S_{\rm RO}(t)\) rotates, \((1,2,1,0,1,...)\). Assume the state of the ring oscillator is sampled periodically with a sampling period of \(T_{a}=A-t_{\rm prop}\). Then, the observed change in the state of the ring oscillator between two samples (\(S_{\rm RO}(t=T_{a})-S_{\rm RO}(t=0)\)) is equivalent to \(|A_{N}|\) where \(A\) is a positive integer value. Therefore, to perform a modulo against a modulus value \(m\), the number of inverters \(N\) should be equal to \(m\). The dividend number \(A\) and the sampling period can be adjusted by changing the analog input voltage to a voltage-to-time converter (VTC).

In a modular dot product or an MVM operation, the dividend \(A\) is replaced by the output of the dot product. Analog dot products can be performed using traditional methods with no change with any desired analog technology where output can be represented as an analog electrical signal (e.g., current or voltage) before the analog modulo.

### Modular Arithmetic with Phase Shifters

The amount of phase shift introduced by a single dual-rail phase shifter when \(v\) and \(-v\) voltages are applied on the upper and the bottom arms, respectively, is

\[\Delta\Phi=\frac{vL}{V_{\rm{\pi-cm}}}, \tag{18}\]

where \(V_{\rm{\pi-cm}}\) is the modulation efficiency of the phase shifter and is a constant value. \(\Delta\Phi\) is proportional to both the length of the shifter \(L\) and the amount of applied voltage \(v\). Figure 7b shows an example modular dot product operation between two vectors, \(x\) and \(w\), using cascaded dual-rail phase shifters. \(w\) is encoded digit-by-digit using phase shifters with lengths proportional to \(2^{j}\) where \(j\) represents the digit number. In the example, each element (i.e., \(w_{0}\) and \(w_{1}\)) of the 2-element vector \(w\) consists of 3 digits and uses 3 phase shifters, each with lengths \(L,2L\), and \(4L\). If the \(j\)-th digit of the \(i\)-th element of \(w\), \(w_{i}^{j}=1\), a voltage \(v_{i}\) is applied to the phase shifter pair (top and bottom) with the length \(2^{j}L\). If the digit \(w_{i}^{j}=0\), then no voltage is applied and therefore no phase shift is introduced to the input signal. To encode the second operand \(x\), a voltage \(v_{i}\) that is proportional to \(x_{i}\) is applied to all non-zero digits of \(w_{i}\). To take modulo with a modulus \(m\) instead of 2\(\pi\), the input \(x\) and therefore the applied voltage \(v\) should be multiplied by the constant \(2\pi/m\). For encoding \(x_{i}\),

\[v_{i}=x_{i}\cdot\frac{V_{\rm{\pi-cm}}}{\pi L}\cdot\frac{2\pi}{m}, \tag{19}\]

should be applied so that the total phase shift at the end of the optical path is

\[\Delta\Phi_{\rm{total}}=\Big{|}\frac{2\pi}{m}\sum_{i}\big{(}\sum_{j}(2^{j}w_{ i}^{j})x_{i}\big{)}\big{|}_{2\pi}=\frac{2\pi}{m}\big{|}\sum_{i}(w_{i}x_{i}) \big{|}_{m}. \tag{20}\]

The resulting output values are collected at the end of the optical path and are in the form of the phase difference between input and output. These outputs are then re-multiplied by \(m/2\pi\) to obtain the outputs of the modular dot products for each residue.

## Extended RNS

By combining RNS and PNS, an integer value \(Z\) can be represented as \(D\) separate digits, \(z_{d}\) where \(d\in\{0,1,...,D-1\}\) and \(0\leq z_{d}<M\) where \(M\) is the RNS range:

\[Z=\sum_{d=0}^{D-1}z_{d}M, \tag{21}\]

and can provide up to \(D\log_{2}M\) bit precision. This hybrid scheme requires carry propagation from lower digits to higher digits, unlike the RNS-only scheme. For this purpose, one can use two sets of moduli, primary and secondary, where every operation is performed for both sets of residues. After every operation, overflow is detected for each digit and carried over to the higher-order digits.

Let us define and pick \(n_{p}\) primary moduli \(m_{i}\), where \(i\in\{1,...,n_{p}\}\) and \(n_{s}\) secondary moduli \(m_{i}\), where \(j\in\{1,...,n_{s}\}\) and \(m_{i}\neq m_{j}\)\(\bigvee\{i,j\}\). Here \(M=M_{p}\cdot M_{s}=\prod_{i=1}^{n_{p}}m_{i}\cdot\prod_{i=1}^{n_{s}}m_{j}\) is large enough to represent the largest possible output of the operations performed in this numerical representation and \(M_{p}\) and \(M_{s}\) are co-prime.

To execute an operation in this hybrid number system, the operation is performed separately for each digit of the output. These operations for each digit are independent of one another and can be parallelized except for the overflow detection and carry propagation. Assume \(z_{d}=z_{d}|_{p_{i}\times}\) consists of primary and secondary residues and is a calculated output digit of an operation before overflow detection.

\(z_{d}\) can be decomposed as \(z_{d}|_{p}=Q_{d}|_{p}M_{p}+R_{d}|_{p}\) where \(Q_{d}|_{p}\) and \(R_{d}|_{p}\) are the quotient and the remainder of the digit, with respect to the primary RNS. To detect a potential overshift in the digit \(z_{d}\), a base extension from primary to secondary RNS is performed on \(z_{d}|_{p}\) and the base extended residues are compared with the original secondary residues of the digit, \(z_{d}|_{s}\). If the residues are the same, this indicates that there is no overflow, i.e., \(Q_{d}|_{p_{i}\times}=0\), and both primary and secondary residues are kept without any error moved to the next higher digit. As against that, if the base-extended secondary residues and the original secondary residues are not the same, it means that there exists an overflow (i.e., \(Q_{d}|_{p_{i}\times}\neq 0\)). In the case of overflow, the remainder of the secondary RNS, \(R_{d}|_{s}\), is calculated through a base extension from primary to secondary RNS on \(R_{d}|_{p}\), where \(R_{d}|_{p}=z_{d}|_{p}\). \(Q_{d}|_{s}\) can then be computed as \(Q_{d}|_{s}=(z_{d}|_{s}-R_{d}|_{s})M_{p}^{-1}\) where \(|M_{p}\cdot M_{s}^{-1}|_{M_{s}}=1\). \(Q_{d}|_{p}\) is calculated through base extension from the secondary to primary RNS on the computed \(Q_{d}|_{s}\). The full quotient \(Q_{d}|_{p_{i}\times}\) is then propagated to the higher-order digit. Algorithm \(T\) shows the pseudo-code for handling an operation \(\square\) using the extended RNS representation. The operation can be replaced by any operation that is closed under RNS.

It should be noted that \(z_{d}|_{p_{i}\times}\) is not always computed as \(x_{d}|_{p_{i}\times}\square q_{d}|_{p_{i}\times}\). For operations such as addition, each digit before carry propagation is computed by simply adding the same digits of the
operands, i.e., \(z_{d}|_{psz}=x_{d}|_{psz}+y_{d}|_{psz}\). However, for multiplication, each digit of \(z_{d}|_{psz}\) should be constructed as in long multiplication. The multiplication of two numbers in the hybrid number system with \(D_{x}\) and \(D_{y}\) digits requires \(D_{x}D_{y}\) digit-wise multiplications and the output will result in \(D_{x}=D_{x}+D_{y}\) digits in total. Similarly, a dot product is a combination of multiply and add operations. If two vectors with \(h\) elements where such element has \(D_{x}\) and \(D_{y}\) digits, the output will require in \(D_{x}=D_{x}+D_{y}+\log_{2}h\) digits.

**Algorithm 1** **Pseudocode for performing the operation \(\square\) using the hybrid number system.** Here, \(x\) and \(y\) are the inputs for operation \(\square\) and \(z\) is the output with \(D\) digits. \(z_{d}\) represents the digits of the output where \(z_{d}|_{ps}\) are the primary residues and \(z_{d}|_{s}\) are the secondary residues. Primary and secondary residues together are referred to as \(z_{d}^{\prime}|_{psz}\). \(Q\) is the quotient and \(R\) is the remainder where \(z_{d}=Q_{d}M_{p}+R_{d}\). \(\mathrm{p2s}()\) and \(\mathrm{s2p}()\) refer to base extension algorithms from primary to secondary residues and from secondary to primary residues, respectively.

```
1:\(Q_{-1}|_{psz}=0\)
2:for\(d\gets 0\) to \(D_{z}\)do
3:\(z_{d}^{\prime}|_{psz}=(x|_{psz},\,\square\,\,y|_{psz})_{d}\)
4:endfor
5:for\(d\gets 0\) to \(D_{z}\)do
6:\(z_{d}|_{psz}=z_{d}|_{psz}+Q_{d-1}|_{psz}\)
7:\(R_{d}|_{psz}=z_{d}|\)
8:\(R_{d}|_{s}=p2s(R_{d}|_{p})\)
9:if\(R_{d}|_{s}=z_{d}|_{s}\)then
10:\(d|_{psz}=0\)
11:else
12:\(Q_{d}|_{psz}=(z_{d}^{\prime}|_{s}-R_{d}|_{s})M_{p}^{-1}\)
13:\(Q_{d}|_{ps}=z\mathrm{p}Q(Q_{d}|_{s})\)
14:endif
15:endfor
```

**ACKNOWLEDGEMENTS**

We thank Dr. Rashmi Agrawal and Prof. Vijay Janapa Reddi for their insightful discussions.

## Author contributions

D.B. conceived the project idea. C.D. and D.B. developed the theory. C.D. implemented the accuracy modeling and the analytical error models with feedback from D.B. and A.J. C.D. and L.N. conducted the experiments. D.B. and A.J. supervised the project. C.D. wrote the manuscript with input from all authors.

## Competing interests

The authors declare the following patent application: U.S. Patent Application No.: 17 / 543,676. L.N. and D.B. declare individual ownership of shares in Lightmatter, a startup company developing photonic hardware for AI.

Figure 7: **Analog modulo implementations.****a** Modulo operation performed using a ring oscillator. A ring oscillator with \(N=3\) inverters is shown to perform modulo against a modulus \(m=3\). This operation is performed after every analog dot product to perform a modular dot product. **b** Modular dot product performed using phase shifters. A modular dot product operation between two \(2\)-element vectors \(x\) and \(w\), each with \(3\) digits, is shown by using a dual-rail set of cascaded phase shifters. The transistor switch turns on and supplies voltage to the phase shifter when the corresponding digit of \(w\) is \(1\).