DCT-CryptoNets: Scaling Private Inference in the Frequency Domain

## Abstract

Abstract The convergence of fully homomorphic encryption (FHE) and machine learning offers unprecedented opportunities for private inference of sensitive data. FHE enables computation directly on encrypted data, safeguarding the entire machine learning pipeline, including data and model confidentiality. However, existing FHE-based implementations for deep neural networks face significant challenges in computational cost, latency, and scalability, limiting their practical deployment. This paper introduces DCT-CryptoNets, a novel approach that leverages frequency-domain learning to tackle these issues. Our method operates directly in the frequency domain, utilizing the discrete cosine transform (DCT) commonly employed in JPEG compression. This approach is inherently compatible with remote computing services, where images are usually transmitted and stored in compressed formats. DCT-CryptoNets reduces the computational burden of homomorphic operations by focusing on perceptually relevant low-frequency components. This is demonstrated by substantial latency reduction of up to 5.3 × \times × compared to prior work on image classification tasks, including a novel demonstration of ImageNet inference within 2.5 hours, down from 12.5 hours compared to prior work on equivalent compute resources. Moreover, DCT-CryptoNets improves the reliability of encrypted accuracy by reducing variability (e.g., from ±2.5% to ±1.0% on ImageNet). This study demonstrates a promising avenue for achieving efficient and practical privacy-preserving deep learning on high resolution images seen in real-world applications.

## 1 Introduction

Escalating concerns related to privacy and security in machine learning have fueled exploration of private inference techniques. These approaches aim to protect both sensitive data and model parameters while maintaining a high quality user experience, especially when related to inference latency and accuracy. To address these challenges, private inference solutions based on cryptographic principles, such as fully homomorphic encryption (FHE) have been proposed. However, such strong security guarantees often comes with significant computational overhead and latency, creating barriers to widespread adoption.

Early work on fully homomorphic encrypted neural networks (FHENNs) faced limitations in both latency and accuracy. Due to the limited native operations of homomorphic encryption, primarily addition and multiplication, many prior methods resorted to approximating non-linear activation functions using polynomials [, , ]. However, this approach introduces accuracy degradation as networks deepen, due to the cumulative effect of approximation errors. Newer homomorphic encryption schemes like TFHE (FHE over the Torus) can handle non-linear activation functions without the need for approximations. Even with such features, optimizing the efficiency of homomorphic operations (HOPs), which include convolutions and non-linear activations in the context of neural networks, remains a key area of research.

To reduce the computational burden of HOPs in FHENNs, previous work has investigated strategies for optimizing convolutions in the encrypted domain [, , , , ] and designing architectures that minimize the use of non-linear activations [, ]. In this work, we prioritize optimizing non-linear activations by operating in the frequency domain. This approach is driven by the significant computational cost of non-linear activations in FHE (e.g., ReLU operations consuming $\sim$32.6% of total inference time []), and their heightened sensitivity to spatial dimensions. As demonstrated in [], these activations are disproportionately concentrated in the early layers of networks where spatial dimensionality is the largest (e.g., 48% within the first quarter of a ResNet-18 network).

Figure: Figure 1: Scalability of state of the art image classification methods in FHENN. DCT-CryptoNets is able to reduce latency by 5.3$\times$ compared to only other method able to infer on ImageNet (SHE []). To ensure a fair comparison, SHE latency values were normalized to the same computational resources as DCT-CryptoNets. CKKS-based methods have difficulty scaling to larger networks and datasets due to their highly approximate nature.(^2^22Lee et al. (2) [] to scale to a ResNet-110 (1.7M parameters). Kim et al [] scale to a Plain-18 network (ResNet-18 without skip connections) but only encrypt the last 8 layers when running on ImageNet.)
Refer to caption: x1.png

While notable advancements have been made, many FHENN optimizations remain tailored to small networks and images (e.g., 32$\times$32). Scaling FHENN to ImageNet and larger networks presents a formidable challenge. Increasing both network size and image dimensions introduces latency from not only convolutions but also non-linear activations, which are "free" in unencrypted networks, and an expensive homomorphic bootstrapping operation []. This homomorphic bootstrap is used to "reset" noise in the ciphertext that accumulate for every encrypted operation (addition and multiplication), which can eventually corrupt the ciphertext making decryption impossible. Approximately 31.6% of total inference time is spent on this bootstrapping operation []. While attempts have been made to implement FHENN on ImageNet, these efforts highlight the substantial trade-offs involved: either prohibitive latency (e.g., 2.5 days for ResNet-18 []) or severely limited encryption scope (e.g., encrypting only 8 layers in ResNet-18 []).

This work introduces DCT-CryptoNets, a novel framework that addresses the computational challenges of fully homomorphic encrypted neural networks (FHENNs). We utilize the Discrete Cosine Transform (DCT) to convert image tensors into frequency tensors with 8$\times$8 filters, significantly reducing spatial dimensionality. This not only aligns with the human visual system’s differential sensitivity to perceptually relevant low-frequency information [] but also mitigates the computational burden of non-linear activations by 34.8%. This yields two additional advantages: (1) it reduces computationally expensive homomorphic bootstrapping, as fewer ReLU activations result in less ciphertext noise accumulation, and (2) it improves the stability of encrypted accuracy through the reduction of bootstrap operations which accumulate approximation errors. Additionally, the emphasis on low-frequency information boosts accuracy compared to traditional RGB-based CNNs due to focusing on visually salient information. Overall, our method demonstrates substantial latency improvements in convolution-based FHENNs across a range of image classification datasets, culminating in a novel demonstration of ImageNet inference within 2.5 hours – a significant advancement over prior work that required an estimated 12.5 hours on equivalent compute resources (previously reported as 2.5 days) []. These results underscore the potential of DCT-CryptoNets for accelerating privacy-preserving deep learning applications.

Our approach makes the following contributions:

- •
We propose DCT-CryptoNets to achieve significant latency improvements in FHENNs. Our focus on low-frequency components reduces the impact of computationally expensive non-linear activations and homomorphic bootstrapping, resulting in a 5.3$\times$ latency reduction on ImageNet, while maintaining or even boosting accuracy compared to RGB-based networks due to the focus on perceptually salient information.
- •
We show that DCT-CryptoNets also bolsters the reliability of encrypted accuracy. By mitigating the need for homomorphic bootstrap operations, these optimizations curb error accumulation. This results in a notable reduction in encrypted accuracy variability (e.g., from ±2.5% to ±1.0% on ImageNet).
- •
We show that DCT-CryptoNets exhibits superior scalability with increasing resolution. This is evident in the amplified reduction of homomorphic operations (HOPs) observed for larger images (e.g., a 33.1% vs. 44.1% reduction in HOPs when applying DCT-based frequency optimizations to a 224$\times$224 vs. 448$\times$448 image respectively).

## 2 Background and Related Work

### 2.1 Crytographic Protocols for Private Inference

Homomorphic encryption relies on lattice-based cryptography [] and the Learning with Errors (LWE) problem [], leveraging the computational hardness of solving equations on high-dimensional lattices with added noise. Lattice-based cryptography has gained significant recognition, with 3 out of the 4 finalists in the National Institute of Standards and Technology (NIST) post-quantum cryptography standardization process being based on this approach.

Many state-of-the-art private inference techniques leverage hybrid, "interactive" approaches that combine homomorphic encryption (HE) with other cryptographic protocols such as multi-party computation (MPC) [, , ]. In MPC, multiple parties jointly compute a function on their private inputs without disclosing those inputs to one another. While ensuring no party learns more than the final result, MPC still can leak information as communication between parties is necessary. Although robust, these methods still pose a security risk in low-trust environments.

In contrast, "non-interactive" FHE-only methods offer superior data confidentiality. FHE ensures that neither raw data nor intermediate values are exposed in plaintext. This makes FHE particularly well-suited for scenarios with highly sensitive data and model parameters, especially in situations where there is limited trust between parties. However, this enhanced privacy comes at the cost of increased computational overhead compared to MPC and hybrid approaches.

### 2.2 Limitations of Existing FHENN Schemes

FHE schemes serve as the fundamental cryptographic building blocks for various application-specific methodologies. The choice of an FHE scheme involves a careful evaluation of the trade-offs inherent to each scheme to ensure optimal performance. FHENNs based on earlier schemes such as BFV [] and BGV [] were known for their efficiency for encrypted addition and multiplication. However, these methods often faced scalability challenges due to their reliance on polynomial approximations of activations (PAAs) and pooling operations. PAAs introduce accuracy degradation due to the cumulative effect of approximation errors in deeper networks. To mitigate accuracy degradation, techniques to increase the polynomial degree of PAAs have been introduced []. Despite this, the computational cost of PAA-based non-linear activations increases exponentially with network depth, becoming a major bottleneck to latency in deeper networks []. A more recent scheme, CKKS [], offers a compelling advantage for neural network applications by operating directly on floating-point numbers. Nevertheless, CKKS inherits the same challenges associated with PAAs and also introduces additional accuracy concerns due to its reliance on approximate arithmetic, which can lead to significant error accumulation in deep networks.

Further efforts to optimize PAA-based methods have shown promise but remain limited. Lee et al. [] introduced a binary-tree implementation for ReLU in the CKKS scheme, yet scalability is confined to smaller models like ResNet-20. Falcon [] introduced fast homomorphic discrete Fourier transform (HDFT) for convolutions and fully connected layers in BFV, significantly reducing operations. However, the approach still suffers from limited accuracy (76.5% on CIFAR-10). Kim et al. [] extended HDFT to CKKS, but only the final 8 layers of a Plain-18 network are encrypted when operating on ImageNet. Lee et al. [] proposed removing the imaginary components of PAAs, thus enabling scalability up to ResNet-110 (1.7M parameters). While PAA-based methods have shown promise for smaller networks, their inherent constraints in handling increased depth and computational complexity hinder their scalability to deeper networks.

### 2.3 Advantages of TFHE

In contrast to other HE schemes, TFHE (FHE over the Torus) operates within the domain of the torus modulo 1, representing ciphertexts as elements of this structure. TFHE excels in performing fast and exact binary operations on encrypted bits, utilizing integer and logic gates. The foundation for these operations lies in the M-th cyclotomic polynomial, denoted as $\Phi(X)$. Its degree, represented by $N$, is typically chosen as a power of 2 for efficiency reasons, and simplifies $\Phi(X)$ to $X^{N}+1$. By defining polynomial rings over real coefficients $R_{N}[X]:=\mathbb{R}[X]/(X^{N}+1)$ and integer coefficients $Z_{N}[X]:=\mathbb{Z}[X]/(X^{N}+1)$, we establish the Torus polynomial ring $\mathbb{T}_{N}[X]:=R_{N}[X]/Z_{N}[X]=\mathbb{T}[X]/(X^{N}+1)$ which forms a $\mathbb{Z}_{N}[X]$-module. This algebraic structure is fundamental to TFHE, facilitating both addition and external multiplication by polynomials of $\mathbb{Z}_{N}[X]$.

Unlike HE schemes that rely on PAAs, TFHE’s ability to directly implement non-linear activations using Boolean/integer arithmetic is a key factor in scalability. Directly implementing non-linear activations avoids the accuracy degradation often associated with PAAs in deeper networks. SHE (Lou and Jiang []), a TFHE-based FHENN, is able to show scalability to ImageNet. They do so by employing a bit-series representation and techniques like logarithmic weight quantization and bit-shift-based convolutions. However, SHE still suffers from prohibitive latency on ImageNet (e.g., ResNet-18 in 2.5 days, ShuffleNet in 5 hours per image). Furthermore, SHE utilizes a leveled TFHE scheme which necessitates higher multiplicative depths and larger ciphertexts for deeper networks.

In our approach, we apply programmable bootstrapping mechanisms (PBS) [] to support arbitrarily deep neural networks. PBS serves two crucial purposes: (1) better ciphertext noise reduction by reordering rotation and key-switch ciphertext operations and (2) enabling homomorphic evaluation of any function expressible as a lookup-table. PBS’s ability to homomorphically evaluate functions expressed as lookup-tables makes it well-suited for implementing non-linear activation functions.

### 2.4 Hyper-quantization Background

Hyper-quantization is a lossy compression technique that improves the efficiency of neural network models by reducing the precision of numerical representations (weights and activations). This not only lowers memory requirements and accelerates computation but also naturally aligns with the integer-based polynomial representation in TFHE, facilitating efficient computation within the encrypted domain. However, hyper-quantization often leads to a trade-off in accuracy as the limited representation can introduce errors.

Quantization-aware training (QAT) can help mitigate these accuracy trade-offs by simulating the effects of quantization during the training process. By constraining weights and activations to fixed-point representations, QAT intentionally introduces quantization noise during training, enabling the network to learn and adapt to these errors through gradient-based optimization. Crucially, "fake quantization" is employed to maintain full-precision weights for smoother convergence []. In the context of uniform quantization, we convert a real value $r\in[\alpha,\beta]$ into a b-bit integer $q=\lfloor\frac{r}{S}+Z\rfloor$,
where $S=\frac{\beta-\alpha}{2^{b}-1}$ represents the quantization scale and Z is the zero-point. Dequantization is achieved by the inverse operation: $r=S(q-Z)$. Previous efforts to quantize FHENNs have produced promising results. Notably, [] achieved successful inference on a VGG-9 network using an 8-bit quantized TFHE scheme with programmable bootstrapping (PBS). Their approach achieved 87.5% accuracy on a VGG-9 network but still had significant latency of 18,000 seconds for inference on the CIFAR-10 dataset. More aggressive quantization can also yield latency reductions, such as a 40% decrease in runtime when moving from an 8-bit to a 2-bit BFV-based FHENN for CIFAR-10 []. Quantization-aware training facilitates the seamless conversion of our models into a TFHE-compatible framework, enabling us to maintain high accuracy while significantly reducing computational overhead.

### 2.5 Frequency Domain Background

Figure: Figure 2: Frequency base pre-processing proposed by [] and DCT-CryptoNets proposed network architecture. Changes from method to method are emphasized in darker purple. Going from RGB-based ResNet head to DCT ResNet head includes changes to first convolution layer and the exclusion of the pooling layer. Changes from the Original DCT-based ResNet head to DCT-CryptoNets ResNet head include pruning the ReLU operator after the first convolution layer as proposed by [, ].
Refer to caption: x2.png

In a departure from prior work, our method operates directly in the frequency domain, utilized the Discrete Cosine Transform (DCT) - a key component of JPEG compression, widely used for image transmission and storage. This allows our method to be directly compatible with machine learning as a service (MLaaS) systems and other applications where image data is transmitted in compressed formats for remote analysis. The 1-D DCT transform uses the following equation where $x_{n}$ represents a signal and $X_{k}$ represent the DCT coefficients. DCT in 2-D is the same 1-D equation applied to the width and height dimensions.

$$ $X_{k}=\sum_{n=0}^{N-1}x_{n}\cos\left[\frac{k\pi}{N}\left(n+\frac{1}{2}\right) \right]\quad\quad k=0,\dots,N-1.$ (1) $$

While the DCT itself is lossless and reversible, by selectively retaining only low-frequency components we can reduce data requirements while preserving image classification accuracy []. This approach leverages the human visual system’s differential sensitivity to various frequency components, allowing models to focus on the most perceptible elements. Adversarially robust object recognition models designed to resist perceptible perturbations have been shown to primarily rely on this low-frequency information [, ]. Additionally, utilizing DCT components directly can improve the privacy preservation of recognition systems against various white-box and black-box attacks []. While previous work [] has explored DCT for homomorphic image compression and decompression, our method uniquely retains the encrypted data in the frequency domain throughout the CNN inference process. The shift from high-spatial RGB to low-frequency DCT components in our training approach offers a dual advantage. By prioritizing perceptually relevant information, it holds the potential for improved image classification. Simultaneously, the spatial dimensionality reduction of the DCT significantly lowers the computational demands of homomorphic inference, particularly by reducing the burden of non-linear activations and homomorphic bootstrap operations.

## 3 Methodology

In this paper we propose DCT-CryptoNets, a novel approach for homomorphic inference that achieves scalability and low latency through a training methodology and network topology specifically designed for the frequency domain. Our approach is composed of two key components: (1) A network architecture optimized for the Discrete Cosine Transform (DCT) domain with strategic ReLU reductions and (2) Encryption of the trained network into a TFHE-compatible scheme.

### 3.1 Network Topology in the DCT Domain with ReLU Reductions

**Table 1: Comparison of multiply and accumulate, non-linear activation, programmable bootstrap and overall homomorphic operations for RGB-based (top row) and DCT-based (middle rows) ResNet-18 network. We see that when moving from the RGB to the DCT domain there is only a slight reduction in MACs but a larger reduction in ReLUs and HOPs. We also see the same reduction in ReLU operations regardless on the number of frequency channels sub-selected, allowing us to use a DCT representation that provides the best task specific accuracy. We observe an additional 11% reduction in HOPs when applying DCT-CryptoNets to a 224$\times$224 vs. 448$\times$448 image respectively, showing that the computational effectiveness of DCT optimizations improve as image resolution increases.**
| ImageNet-sized Images | Large(er) Images |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Dimension | #MACs | #ReLUs | #PBS | #HOPs | Dimension | #MACs | #ReLUs | #PBS | #HOPs |
| 3$\times$224^2 | 1.82G | 2.31M | 22.4M | 1.85G | 3$\times$448^2 | 7.29G | 9.23M | 89.3M | 7.67G |
| 6$\times$56^2 | 1.70G | 1.51M | 15.5M | 1.24G | 6$\times$112^2 | 6.82G | 6.02M | 50.7M | 4.29G |
| 24$\times$56^2 | 1.71G | 1.51M | 15.5M | 1.26G | 24$\times$112^2 | 6.83G | 6.02M | 50.9M | 4.33G |
| 48$\times$56^2 | 1.71G | 1.51M | 15.6M | 1.26G | 48$\times$112^2 | 6.85G | 6.02M | 51.2M | 4.35G |
| 64$\times$56^2 | 1.72G | 1.51M | 15.6M | 1.27G | 64$\times$112^2 | 6.86G | 6.02M | 51.3M | 4.38G |
| 192$\times$56^2 | 1.74G | 1.51M | 15.7M | 1.28G | 192$\times$112^2 | 6.97G | 6.02M | 51.7M | 4.41G |
| Max $\Delta$<br>RGB $\rightarrow$ DCT | -6.54% | -34.8% | -30.0% | -33.1% |  | -6.54% | -34.8% | -43.9% | -44.1% |

Following the methodology in [], we first transform RGB images to YCrCb color space, then apply the Discrete Cosine Transform (DCT) to generate frequency domain representations. We adopt standard JPEG compression’s 8$\times$8 filtering scheme, yielding 64 frequency channels per YCrCb color space. This process effectively downsamples spatial dimensions (H, W) by a factor of 8 while increasing channel dimensions (C) by a factor of 8^2. Subsequently, we sub-select a fixed portion of the low-frequency channels, emphasizing luma (Y) components due to their higher perceptual relevance compared to chroma (Cr, Cb). The selection adheres to a standard 4:2:2 luma-chroma subsampling ratio. Notably, the total number of homomorphic operations (HOPs) remains relatively consistent regardless of the number of sub-selected frequency channels, allowing for flexibility in choosing a network that provides high accuracy (see Table 1). The DCT’s 8$\times$8 filtering of spatial information into frequency channels proves particularly advantageous as image size increases. We observe that DCT becomes increasingly valuable for HOP optimization as we scale to ImageNet-sized images and beyond. For 448^2 images, we observe a 44.1% reduction in HOPs compared to a 33.1% reduction for 224^2 images. While the percentage of ReLU operations removed remains constant, this amplified HOP reduction at larger image sizes can be attributed to the decreased need for bootstrapping operations, a direct consequence of fewer ReLU activations (see Table 1). This highlights the scalability of DCT-CryptoNets in handling larger inputs.

Given the distinct dimensionality of frequency-domain features (reduced H and W, increased C), we modify the initial stride-2 convolution layer, commonly found in CNNs, with a stride-1 layer. The subsequent layer’s channel size is then adjusted to accommodate the transformed input (see Figure 2). This approach minimally modifies existing CNN architectures to accept frequency-domain input. Further optimization involves pruning the ReLU activations following the channel-widening convolution layer. This reduction in ReLU operations does not significantly impact accuracy, as earlier-layer ReLUs typically exhibit lower importance than those in later layers []. While the skip connection pruning proposed in [] also reduces ReLU count, it incurs a much greater accuracy cost and also increase HOPs (see Section A.2). Therefore, we opted for a network architecture that specifically incorporates first-layer ReLU pruning as shown in Fig. 2.

While DCT offers significant benefits for larger images, its direct application to lower resolutions can lead to excessive spatial dimension reduction. To address this challenge, we introduce a second specialized architecture, tailored for smaller inputs (e.g., 32$\times$32 pixels). This adaptation utilizes a 4$\times$4 DCT filter, resulting in 48 frequency channels, and incorporates architectural adjustments to maintain spatial resolution and prevent information loss (see Section A.3 for an architecture deep-dive). Despite an increased parameter count, this architecture achieves comparable latency and a 4% accuracy improvement over a traditional ResNet-20 on CIFAR-10. Furthermore, even with further spatial reduction from 16$\times$16 to 8$\times$8, we observe similar accuracy to a traditional ResNet-20 coupled with a 4.2$\times$ latency improvement (see Table 2). This demonstrates the effectiveness of DCT-CryptoNets even in low resolution settings.

**Table 2: Evaluating performance on low resolution images by comparing the traditional ResNet-20 and our proposed DCT-CryptoNets ResNet-20 on CIFAR-10. For DCT-CryptoNets ResNet-20, various combinations of retained frequency channels and spatial input sizes were explored. Our findings indicate that retaining the top 24 low-frequency channels (out of 48) and a spatial size of 16$\times$16 leads to a 4% accuracy improvement over the traditional ResNet-20 model while maintaining comparable latency.**
|  | Input<br>Dimension | Model | Accuracy | Latency (s) |
| --- | --- | --- | --- | --- |
| RGB | 3$\times$32^2 | Traditional ResNet-20 | 86.5% | 603 |
| 3$\times$32^2 | DCT-CryptoNets ResNet-20 | 91.6% | 1,339 |  |
| DCT | 24$\times$8^2 | DCT-CryptoNets ResNet-20 | 85.2% | 137 |
| 48$\times$8^2 | DCT-CryptoNets ResNet-20 | 86.5% | 144 |  |
| 24$\times$16^2 | DCT-CryptoNets ResNet-20 | 90.5% | 565 |  |
| 48$\times$16^2 | DCT-CryptoNets ResNet-20 | 90.4% | 567 |  |

### 3.2 Encrypting into a TFHE Compatible Scheme

We first employ a quantization-aware training (QAT) framework on the preprocessed data and chosen network topology. To achieve an optimal balance between accuracy and latency for our FHENNs, we systematically explored various quantization levels (see Appendix A.1). Our approach employs a 4-bit symmetric quantization scheme with a fixed zero-point for all tasks except ImageNet, where 5-bit quantization is used. These choices strike a balance between efficiency and accuracy, allowing us to perform the entire neural network computation directly on encrypted numbers within the TFHE framework.

To fully encrypt the trained neural network within the TFHE scheme, we employ an automated optimization process []. This process balances three key hyperparameters: (1) the circuit bit-width, defined as the minimum number of bits required to represent the largest integer arising during computation. This generally mimics the 4-bit or 5-bit integer used during QAT; (2) precision rounding for model accumulators, which implements a scaling factor used to remove least significant bits; and (3) the desired error probability for programmable bootstrapping (PBS) operations. Unlike polynomial approximation (PAAs) that introduce inherent approximation errors, PBS error probability is a tunable hyperparameter. It controls the likelihood of a small error value added to the look-up table (LUT) operation. By carefully tuning these hyperparameters, the optimization process determines the cryptosystem parameters that ensure efficient execution.

$$ $LUT[x]=\left\{\begin{array}[]{cl}T[x],&\text{with probability }(1-p_{err})\\ T[x+k],&\text{with probability }p_{err},\;k=(\pm 1,\pm 2,...)\end{array}\right.$ (2) $$

Determining optimal cryptographic hyperparameters involves empirical exploration due to the indirect control over the underlying cryptosystem parameters. Decreasing the PBS error probability or increasing the precision rounding threshold to allow more bits necessitates additional homomorphic operations (HOPs). This presents a trade-off: while enhancing accuracy, it also increases latency. We notice that for simpler tasks, a precision rounding of 6 and a PBS error probability of 0.01 achieve a good balance. However, more complex tasks like ImageNet require further hyperparameter tuning to maintain accuracy. For instance, increasing precision rounding to 7 reduces bit truncation but leads to a higher number of HOPs, thus increasing latency (see Appendix A.4 for a detailed analysis).

## 4 Results

### 4.1 Experimental Setup

DCT-CryptoNets utilizes several tools and frameworks. Image conversion to the DCT domain is performed using libjpeg-turbo, Brevitas [] facilitates quantization-aware training, and Concrete-ML [] enables encryption within the TFHE scheme. Neural network training is conducted on an RTX A40 GPU and FHENN latency measurements are obtained from dual AMD Ryzen Threadripper PRO 5965WX processors (96-threads total). Each network is trained on CIFAR-10, mini-ImageNet, Imagenette, and ImageNet, with varying configurations of DCT components. Data augmentation strategies include random cropping, color jitter, and random flipping. To assess FHENN accuracy, we leverage Concrete-ML’s simulation accuracy feature, allowing us to efficiently estimate expected accuracy and gather valuable metrics on the compiled FHENN. Latency measurements are conducted by processing a single image at a time on a dedicated machine with no background tasks running, ensuring maximum utilization of all available threads.

### 4.2 Accuracy and Reliability Enhancements with Low-Frequency Information

**Table 3: Top-1 accuracy of datasets with varying levels of retained low-frequency components, ranging from a highly lossy 6-channel representation to a lossless 192-channel representation. Accuracies are reported as unencrypted plus or minus a 95% confidence interval generated by the encryption process as explained in Section 4.2. As DCT models per dataset share similar number of HOPs and cryptographic hyperparameters, their confidence intervals are consistent.**
|  | Model | Input<br>Dimension | CIFAR-10<br>(10 classes) | mini-ImageNet<br>(100 classes) | Imagenette<br>(10 classes) | ImageNet<br>(1K classes) |
| --- | --- | --- | --- | --- | --- | --- |
| RGB | ResNet-18 | 3$\times$224^2 | 92.4$\pm$2.4% | 88.9$\pm$2.4% | 88.5$\pm$2.0% | 66.1$\pm$2.5% |
| DCT | ResNet-18 | 6$\times$56^2 | 89.7$\pm$0.6% | 81.6$\pm$1.8% | 84.3$\pm$0.4% | 55.5$\pm$1.0% |
| ResNet-18 | 24$\times$56^2 | 91.2$\pm$0.6% | 90.0$\pm$1.8% | 87.5$\pm$0.4% | 65.8$\pm$1.0% |  |
| ResNet-18 | 48$\times$56^2 | 91.7$\pm$0.6% | 90.1$\pm$1.8% | 86.4$\pm$0.4% | 66.1$\pm$1.0% |  |
| ResNet-18 | 64$\times$56^2 | 92.4$\pm$0.6% | 89.5$\pm$1.8% | 86.5$\pm$0.4% | 66.3$\pm$1.0% |  |
| ResNet-18 | 192$\times$56^2 | 92.3$\pm$0.6% | 89.7$\pm$1.8% | 83.8$\pm$0.4% | 64.1$\pm$1.0% |  |

To demonstrate the impact of focusing on visually salient low-frequency information we evaluated model accuracy across CIFAR-10, mini-ImageNet, Imagenette, and ImageNet on upsampled 3$\times$224^2 RGB inputs and their DCT-based representations with varying frequency components (see Table 3). Due to the computational cost of obtaining simulation accuracy results in Concrete-ML (approximately 8 seconds per ImageNet image), comprehensive validation on the full ImageNet validation set was impractical. To estimate the impact of encryption on accuracy, we employed statistical bootstrapping to generate 95% confidence intervals (CIs) for each model. This involved repeatedly (10K times) analyzing random combinations of subsets (20 subsets each with 200 random images) to determine accuracy variability. The resulting distribution of accuracies allowed us to estimate the 95% CI for each model, reflecting the expected variability due to encryption.

DCT-based networks consistently matched or outperformed the accuracy of their RGB counterparts, particularly on larger datasets (mini-ImageNet, ImageNet), due to their focus on perceptually relevant low-frequency information. Generally, retaining the top 64 low-frequency channels yielded the best accuracy. This suggests that lossless representations (192 channels) contain unnecessary high-frequency components that hinder learning. Thus, some degree of "lossy-ness" allows the network to prioritize visually salient information, further improving accuracy. Furthermore, DCT-based methods exhibited narrower confidence intervals, indicating greater accuracy stability in the encrypted domain. This improved reliability stems from the -30% reduction in programmable bootstrap (PBS) operations (see Table 1), which individually contribute to error accumulation. DCT-CryptoNets meets or exceeds the accuracy of RGB-based methods while also enhancing the reliability of encrypted accuracy.

### 4.3 Evaluation of Accuracy and Latency

**Table 4: Performance comparison of DCT-CryptoNets and prior work. We selected the 64$\times$56^2 DCT representation for ImageNet and 24$\times$16^2 for CIFAR-10 due to their superior accuracy. The RGB variants, trained on 3$\times$32^2 or 3$\times$224^2 inputs, serve as baselines without DCT optimization so demonstrate the isolated impact of DCT-based optimizations. DCT-CryptoNets show comparable performance on smaller models/datasets but excel in scaling to larger ones, highlighting its potential for real-world applications.**
| Method | Dataset | Input<br>Dimension | Model | Scheme | Accuracy | Latency (s) | Normalized<br>Latency (s)<br>(96-threads) |
| --- | --- | --- | --- | --- | --- | --- | --- |
| CryptoDL [] | CIFAR-10 | 3$\times$32^2 | Custom CNN | BGV | 91.4% | 11,686 | $\sim$ |
| Faster Cryptonets [] | CIFAR-10 | 3$\times$32^2 | Custom CNN | FV-RNS | 75.9% | 3,240 | $\sim$ |
| SHE [] | CIFAR-10 | 3$\times$32^2 | Custom CNN | TFHE | 92.5% | 2,258 | 470 |
| Lee et al. (1) [] | CIFAR-10 | 3$\times$32^2 | ResNet-20 | CKKS | 92.4% | 10,602 | $\sim$ |
| Lee et al. (2) [] | CIFAR-10 | 3$\times$32^2 | ResNet-20 | CKKS | 91.3% | 2,271 | $\sim$ |
| Kim et al. [] | CIFAR-10 | 3$\times$32^2 | Plain-20 | CKKS | 92.1% | 368 | $\sim$ |
| Ran et al. [] | CIFAR-10 | 3$\times$32^2 | ResNet-20 | CKKS | 90.2% | 392 | $\sim$ |
| Rovida et al. [] | CIFAR-10 | 3$\times$32^2 | ResNet-20 | CKKS | 91.7% | 336 | $\sim$ |
| Benamira et al. [] | CIFAR-10 | 3$\times$32^2 | VGG-9 | TFHE | 74.0% | 570 | 48 |
| Stoian et al. [] | CIFAR-10 | 3$\times$32^2 | VGG-9 | TFHE | 87.5% | 18,000 | 3,000 |
| DCT-CryptoNets | CIFAR-10 | 3$\times$32^2 | ResNet-20 | TFHE | 91.6% | 1,339 | 1,339 |
| DCT-CryptoNets | CIFAR-10 | 24$\times$16^2 | ResNet-20 | TFHE | 90.5% | 565 | 565 |
| SHE [] | CIFAR-10 | 3$\times$32^2 | ResNet-18 | TFHE | 94.6% | 12,041 | 2,509 |
| DCT-CryptoNets | CIFAR-10 | 3$\times$32^2 | ResNet-18 | TFHE | 92.3% | 1,746 | 1,746 |
| DCT-CryptoNets | CIFAR-10 | 24$\times$16^2 | ResNet-18 | TFHE | 91.2% | 1,004 | 1,004 |
| SHE [] | ImageNet | 3$\times$224^2 | ResNet-18 | TFHE | 66.8% | 216,000 | 45,000 |
| DCT-CryptoNets | ImageNet | 3$\times$224^2 | ResNet-18 | TFHE | 66.1% | 16,115 | 16,115 |
| DCT-CryptoNets | ImageNet | 64$\times$56^2 | ResNet-18 | TFHE | 66.3% | 8,562 | 8,562 |

DCT-CryptoNets demonstrates competitive accuracy when compared to existing methods on both CIFAR-10 and ImageNet (see Table 4). While CKKS-based methods demonstrate slightly lower latency on smaller models due to their utilization of single instruction multiple data (SIMD) packing and polynomial approximations of activation functions (PAAs), the inherent limitations of PAAs hinder CKKS-based methods from scaling to larger networks and high-resolution images like those in ImageNet. It’s crucial to note that CKKS’s focus on amortized runtime through SIMD packing, a feature unavailable in TFHE, makes direct latency comparisons via normalization less meaningful.

Comparing DCT-CryptoNets to SHE [], the only other method demonstrating scalability to ImageNet, we observe comparable accuracy and latency for smaller models and images. It’s worth noting that SHE’s fastest model on CIFAR-10 is a custom CNN without skip connections, contributing to its slight latency advantage over our ResNet-20 model. As network or image size increases, DCT-CryptoNets showcases superior scalability, with progressively greater latency improvements compared to SHE culminating in a 5.3$\times$ speedup on ImageNet. Furthermore, even without DCT optimizations, larger DCT-CryptoNets ResNet-18 models outperform SHE on both CIFAR-10 and ImageNet. This improvement can be attributed to SHE’s reliance on a leveled TFHE scheme, which necessitates higher multiplicative depths and larger ciphertexts leading to latency amplifications in deeper networks. In contrast, by leveraging programmable bootstrapping, DCT-CryptoNets mitigates these limitations and enables efficient handling of larger models.

Overall, our results demonstrate that DCT-CryptoNets achieves performance on par with previous work on smaller images and networks, while showcasing superior scalability and efficiency gains when applied to larger, more complex tasks.

### 4.4 Limitations and Future Directions

A key limitation of our approach is that performance is highly dependent on the cryptographic hyperparameters and the degree of bit precision during quantization-aware training (QAT). Careful tuning of precision rounding, programmable boostrapping (PBS) error probability and QAT bit-level is essential to navigate the trade-off between accuracy and latency. Future steps should be made to improve the cryptographic and quantization parameter selection process.

Furthermore, the accuracy benefits from DCT optimizations are less pronounced on smaller images (e.g., 32$\times$32) compared to larger ones. This observation aligns with the inherent nature of small images, which often contain less high-frequency information that DCT filtering typically removes. Consequently, the impact of focusing on low-frequency components is less significant for these smaller inputs. Future work could explore techniques to enhance the accuracy benefits of DCT for smaller images, potentially through adaptive filtering or alternative frequency-domain representations.

## 5 Conclusion

In this paper, we presented DCT-CryptoNets, a novel framework that addresses the critical challenges of scalability and computational cost in fully homomorphic encrypted neural networks (FHENNs), particularly for high resolution images. By combining frequency-domain learning through the Discrete Cosine Transform (DCT), DCT-CryptoNets significantly reduces the computational burden of non-linear activations and homomorphic bootstraps, enabling more efficient inference on large-scale datasets like ImageNet. Our approach demonstrates substantial latency improvements, achieving a 5.3$\times$ speedup compared to the only prior work on ImageNet and a boost in the reliability of encrypted accuracy variability. Furthermore, isolating the impact of DCT-based optimizations reveals a latency improvement ranging from 1.7$\times$ to 2.4$\times$. These advancements showcase the promise of frequency-domain techniques for privacy-preserving deep learning. This not only represents a significant step towards practical deployment of FHE in real-world applications, but also opens new avenues for future research in optimizing private inference for deep learning.

## Acknowledgements

This project was supported from the Purdue Center for Secure Microelectronics Ecosystem – CSME#210205.

## Appendix A Appendix

### A.1 Quantization Ablation on ImageNet

**Table 5: Quantization impact for ResNet-18 on ImageNet**
|  | Quantization | Accuracy | Latency (s) |
| --- | --- | --- | --- |
| RGB<br>(3$\times$224^2) | 4-bit | 60.6% | 12,874 |
| 5-bit | 66.1% | 16,115 |  |
| 8-bit | 68.4% | 75,674 |  |
| DCT<br>(64$\times$56^2) | 4-bit | 62.9% | 6,961 |
| 5-bit | 66.3% | 8,562 |  |
| 8-bit | 68.5% | 41,998 |  |

To examine the impact of quantization on performance, an ablation study was performed varying quantization levels on ImageNet, as detailed in Table 5. Adopting 5-bit quantization, consistent with the approach in SHE [], resulted in a notable accuracy improvement compared to 4-bit quantization, with a manageable increase in latency of approximately 25%. Further increasing the quantization level to 8-bit yielded only marginal accuracy gains, while incurring a substantial increase in latency. These results suggest that 5-bit quantization strikes an effective balance between accuracy and efficiency for large-scale datasets like ImageNet.

### A.2 ReLU Pruning Techniques

**Table 6: Impact of different ReLU pruning techniques (3$\times$224^2 RGB $\rightarrow$ 64$\times$56^2 DCT).**
| $\Delta$: RGB $\rightarrow$ DCT | DCT-Net [] | + First Layer<br>Pruned [] | + Skip Connections<br>Pruned [] | + Both Pruned |  |
| --- | --- | --- | --- | --- | --- |
| Ops. | #ReLUs | -26.1% | -34.8% | -58.7% | -67.4% |
| #HOPs | -21.7% | -33.1% | -24.3% | -25.7% |  |
| Acc. | CIFAR-10 | +0.0% | -0.4% | -2.67% | -2.54% |
| ImageNet | +2.2% | +2.3% | $\sim$ | $\sim$ |  |

DCT-Net [] inherently reduces ReLU operations due to spatial dimension reduction. DCT-CryptoNets further optimizes latency by pruning the first layer’s ReLU’s, with minimal impact on accuracy. However, skip connection ReLU pruning is not recommended as it incurs significant accuracy degradation and increases homomorphic operations even though the number of ReLU operations decreases. This is because removing ReLU after the addition of two quantized tensors necessitates the insertion of a quantization identity function.

### A.3 DCT-CryptoNets for Small(er) Images and Networks

When applying DCT optimizations to smaller images and networks (e.g., ResNet-20 on 32$\times$32 images), adaptations are necessary to address the excessive spatial dimension reduction caused by the standard 8$\times$8 DCT filter. We mitigate this by reducing the DCT filter size to 4$\times$4, resulting in 48 frequency channels (16 per YCrCb component) instead of the typical 192. To accommodate this change, we introduce a modified ResNet-20 architecture with two key adjustments (see Fig. 3):

- •
Downsampling Reduction: One downsampling step is removed to preserve spatial resolution throughout the network.
- •
Channel Expansion: The initial channel dimensions are increased to match the 48-channel DCT output, preventing information loss during the first convolutional layer transition. The modified channel dimensions are now [48, 56, 64].

Although this channel expansion doubles the number of parameters, it enables effective DCT utilization on smaller images. As demonstrated in Table 2, DCT-CryptoNets ResNet-20 achieves a 4% accuracy improvement over the traditional ResNet-20 while maintaining comparable latency.

Figure: Figure 3: Traditional vs. DCT-CryptoNets ResNet-20 Architecture
Refer to caption: x3.png

### A.4 Sensitivity of Cryptographic Hyperparameters in FHENN

**Table 7: Comparing the change of latency, top-1 accuracy and ciphertext memory requirements of a 3$\times$224^2 model on 1000 samples from ImageNet when modulating two encryption hyperparameters (precision rounding and PBS error probability).**
|  | Precision Rounding = 6 | Precision Rounding = 7 | Precision Rounding = 8 |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| PBS Err. | $\Delta$ Latency | $\Delta$ Acc. | $\Delta$ Memory | $\Delta$ Latency | $\Delta$ Acc. | $\Delta$ Memory | $\Delta$ Latency | $\Delta$ Acc. | $\Delta$ Memory |
| 0.05 | -25.6% | -36.8% | -24.4% | -10.7% | -32.2% | -17.9% | +34.0% | -35.7% | +19.1% |
| 0.01 | -12.1% | -21.3% | -6.2% | $\bigstar$ | $\bigstar$ | $\bigstar$ | +81.7% | +0.4% | +56.8% |
| 0.005 | -34.2% | -9.4% | -8.0% | +62.3% | +0.0% | +5.5% | +203.4% | +1.2% | +93.3% |

Encryption of the neural network requires careful selection of cryptographic hyperparameters to balance accuracy and latency. Starting with our pre-selected values for ImageNet (precision rounding of 7 and PBS error probability of 0.01), as detailed in Table 7, we systematically explore the effects of varying these parameters. Reducing either parameter leads to a significant drop in top-1 accuracy. Increasing these parameters generally yields a noticeable increase in latency, with only marginal accuracy gains. Notably, raising the bit-precision rounding to 8 and halving the PBS probability increases top-1 accuracy on ImageNet subsamples by up to 1.2% but incurs a threefold increase in latency.

### A.5 In the context of MLaaS

DCT-CryptoNets leverages the Discrete Cosine Transform (DCT) to operate directly in the frequency domain, aligning with the prevalent use of DCT in image compression standards like JPEG. This enables seamless integration with existing image processing pipelines and facilitates efficient transmission and processing in machine learning as a service (MLaaS) systems and other applications where image data is sent for remote analysis. In this paradigm (Figure 4), a model is trained locally, encrypted, and then deployed in the cloud. During inference, users transform their images into DCT representations (a process often already performed due to JPEG compression) and encrypt them using their private key. The encrypted image is then sent to the cloud-based model for processing, and the resulting encrypted output is returned to the user. To obtain the final prediction, the user decrypts the output of the penultimate layer (prior to the fully-connected layer) and processes the resulting plaintext tensor through a local classifier.

Figure: Figure 4: MLaaS System with DCT-CryptoNets.
Refer to caption: x4.png

### A.6 TFHE-based FHENN Compute Resources

**Table 8: Comparison of TFHE-based methods based on available compute resources.**
| Method | Dataset | Input<br>Dimension | Model | Accuracy | Reported<br>Latency (s) | CPU<br>Threads | Normalized<br>Latency (s)<br>(96-threads) |
| --- | --- | --- | --- | --- | --- | --- | --- |
| SHE [] | CIFAR-10 | 3$\times$32^2 | Custom CNN | 92.5% | 2,258 | 20 | 470 |
| Benamira et al. [] | CIFAR-10 | 3$\times$32^2 | VGG-9 | 74.01% | 570 | 8 | 48 |
| Stoian et al. [] | CIFAR-10 | 3$\times$32^2 | VGG-9 | 87.5% | 18,000 | 16 | 3,000 |
| DCT-CryptoNets | CIFAR-10 | 3$\times$32^2 | ResNet-20 | 91.6% | 1,339 | 96 | 1,339 |
| DCT-CryptoNets | CIFAR-10 | 24$\times$16^2 | ResNet-20 | 90.5% | 565 | 96 | 565 |
| SHE [] | CIFAR-10 | 3$\times$32^2 | ResNet-18 | 94.62% | 12,041 | 20 | 2,509 |
| DCT-CryptoNets | CIFAR-10 | 3$\times$32^2 | ResNet-18 | 92.3% | 1,746 | 96 | 1,746 |
| DCT-CryptoNets | CIFAR-10 | 24$\times$16^2 | ResNet-18 | 90.9% | 1,004 | 96 | 1,004 |
| DCT-CryptoNets | CIFAR-10 | 3$\times$224^2 | ResNet-18 | 92.4% | 11,097 | 96 | 11,097 |
| DCT-CryptoNets | CIFAR-10 | 64$\times$56^2 | ResNet-18 | 92.4% | 6,313 | 96 | 6,313 |
| SHE [] | ImageNet | 3$\times$224^2 | ResNet-18 | 69.4% | 216,000 | 20 | 45,000 |
| DCT-CryptoNets (4-bit) | ImageNet | 3$\times$224^2 | ResNet-18 | 60.6% | 12,874 | 96 | 12,874 |
| DCT-CryptoNets (5-bit) | ImageNet | 3$\times$224^2 | ResNet-18 | 66.1% | 16,115 | 96 | 16,115 |
| DCT-CryptoNets (4-bit) | ImageNet | 64$\times$56^2 | ResNet-18 | 62.9% | 6,961 | 96 | 6,961 |
| DCT-CryptoNets (5-bit) | ImageNet | 64$\times$56^2 | ResNet-18 | 66.3% | 8,562 | 96 | 8,562 |

Since TFHE prioritizes individual inference latency, we normalize prior work’s latency values to the 96-thread resource capacity of DCT-CryptoNets to ensure a fair comparison. This direct normalization based on CPU-threads is motivated by the fact that the Concrete-ML library utilizes 100% of available CPU resources. We noticed when running DCT-CryptoNets on a 24-thread Intel Core i9-12900KF there was exactly 4$\times$ increase in latency compared to the 96-thread dual AMD Ryzen Threadripper PRO 5965WX. It is important to note that many CKKS-based methods utilize single instruction multiple data (SIMD) packing to optimize amortized runtime, a feature not available in TFHE. Consequently, normalizing latency for CKKS-based methods would not accurately reflect their performance characteristics due to their inherent reliance on batch processing.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: See the weakness.
soundness: 3
strengths: $\bullet$ Performing TFHE-based inference in the frequency domain allows the usage of lower-resolution inputs without compromising accuracy. This approach significantly decreases both FLOPs and nonlinear operations (ReLU), while also requiring fewer bootstrapping operations. This results in substantial speedup benefits. More importantly, this makes it feasible to perform inference on larger input images, enhancing the practical applicability (such as semantic segmentation) of homomorphic encryption in neural network inference.


$\bullet$ The authors report ciphertext accuracy, specifically on the ImageNet-1K scale, distinguishing this work from most private inference papers, which typically report plaintext accuracy under the assumption that there is no accuracy loss when operations are conducted in field arithmetic.

$\bullet$ The experimental results are extensive and include a detailed sensitivity analysis of the cryptographic hyper-parameters.
summary: This paper introduces DCT-CryptoNets, which performs neural network (CNN) inference entirely using TFHE-based homomorphic encryption in the frequency domain. Unlike hybrid protocols that limit homomorphic encryption to just linear operations, and require MPC for nonlinear operations, this approach leverages TFHE to perform both linear and nonlinear operations under homomorphic encryption. This enables private inference outsourcing to the server without requiring client interaction for intermediate computations. The authors have shown significant speedup over prior TFHE-based implementation (SHE, NeurIPS'19) on CIFAR-10 and ImageNet datasets.
weaknesses: $\bullet$ The lack of sufficient algorithmic contributions and research insights makes it less suitable for the ML conference. Operating in the frequency domain for private inference benefits is not a novel concept (see [1,2]). Also, the usage of quantization-aware training for lower-frequency components is simply an engineering tweak. 

Thus, a more fitting venue for this work might be a cryptography-focused conference. 

$\bullet$ Moreover, the practicality of HE-only private inference remains questionable, especially when compared to hybrid protocol-based approaches. For example, Cheetah [3] achieves ImageNet-1K inference on ResNet-50 in 80.3 seconds in a LAN setting and 134.7 seconds in a WAN setting. Thus, the primary motivation for pursuing HE-only inference appears to be the benefit of non-interactive private inference.




1. Song et al., ENSEI: Efficient secure inference via frequency-domain homomorphic convolution for privacy-preserving visual recognition, CVPR 2020.

2. Li et al. Falcon: A fourier transform based approach for fast and secure convolutional neural network predictions, CVPR 2020.

3. Huang et al., Cheetah: Lean and fast secure Two-Party deep neural network inference, USENIX Security 2022.

---

confidence: 4
contribution: 4
initial_rating: 8
presentation: 4
questions: Are there any special scaling or normalization techniques that need to be considered when considering the YCrCb color space components of an image?

Can GPUs be used to any advantage in this approach?

Are there any privacy preservation guarantees or "leakage" guarantees that could be developed around this approach.  (I realize this may be challenging mathematically.)
soundness: 4
strengths: Novel DCT based insight for unstructured data yielding excellent computational advantages for high resolution images.

Thorough benchmarking and attention to reproducible science.

Excellent comparative analysis of this CKKS based technique relative to competing TFHE approaches.

Excellent and comprehensive list of references that chronicle the current state of the art and prior advances.
summary: This paper presents a very promising strategy for achieving a practical and computationally efficient FHE-based (CKKS) private inference of deep learning models applied to high resolution images.     In a novel approach, the technique presented relies as a starting point on a Discrete Cosine Transform representation of the image.  It also employs a quantization aware training (QAT) framework.  Thorough comparative benchmarking of accuracy and latency for RGB vs DCT techniques a various image resolutions and at various levels of retained low-frequency components (of the DCT) are presented.  

The paper establishes both a detailed methodology and new "high-water mark" performance capability for ML inference generation for high resolution images.  Though performance is less pronounced on smaller images (32x32) it is the capability on larger images that is most important for future practical applications.
weaknesses: I find no obvious weaknesses.

I would emphasize to the reader perhaps new to the field ( in Section 3.2 on page 6)  that model training is done in the plaintext domain. (even though this is most evident in Figure 3 presented on Page 14.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: see weakness
soundness: 3
strengths: 1. **Frequency-Domain Optimization**: DCT-CryptoNets leverage the Discrete Cosine Transform (DCT) to focus on low-frequency components of images, which enhances the model's ability to capture perceptually salient information while reducing computational complexity and improving accuracy compared to traditional RGB-based networks.

2. **Reduced Latency and Improved Scalability**: The proposed method achieves significant latency reductions (up to 5.3×) during inference, especially on large datasets like ImageNet, while demonstrating superior scalability as image resolution increases. This makes DCT-CryptoNets more efficient for real-world applications of privacy-preserving deep learning.

3. **Enhanced Reliability through Reduced Error Accumulation**: By minimizing the need for homomorphic bootstrap operations, DCT-CryptoNets reduce the accumulation of approximation errors, leading to more reliable predictions and improved encrypted accuracy. This addresses challenges faced by earlier fully homomorphic encryption (FHE) schemes.
summary: The paper presents DCT-CryptoNets, a novel framework that enhances privacy-preserving deep learning by utilizing the Discrete Cosine Transform (DCT) to operate in the frequency domain, significantly reducing latency and computational costs associated with fully homomorphic encrypted neural networks (FHENNs). By focusing on low-frequency information, DCT-CryptoNets improve accuracy and reliability in encrypted predictions while demonstrating superior scalability with increasing image resolution. The work addresses key challenges in existing FHE-based neural networks and emphasizes the importance of optimizing cryptographic and quantization parameters for practical applications in secure image processing.
weaknesses: I have a question about the threat model setting here, why the model is trained locally?

If the client could train the model by themselves, why does they do inference locally.

Or if they want to deploy that encrypted model (key from model trainer) on the cloud for other clients as service. How does the key management should be solved?

Meta-review: The paper proposes a new technique DCT-Cryptonets in order to be able to perform cryptographically private (using Fully Homomorphic Encryption) inference on neural networks, particularly for convolutional neural networks. The main contribution is the method to perform operations in frequency space which has benefits both computationally and to a lesser extent statistically due to focus on low-dimensional Fourier transforms. The authors back up their new method by an extensive empirical evaluation and in particular report results on a scale that have not been reported before.

Decision: Accept (Poster)