Cost-Effective On-Device Sequential Recommendation with Spiking Neural Networks

1 Introduction

Sequential recommendation (SR) systems [Wang et al., 2019] have become indispensable to ubiquitous web applications such as Shopee and TikTok, owing to their exceptional ability to model users' historical behaviors and uncover latent preferences across a wide range of products and services, ultimately driving enhanced business revenue. Most conventional SR systems are entirely server-side solutions [Kang and McAuley, 2018; Lai et al., 2024], heavily dependent on the cloud's substantial storage, memory, and computational resources [Steck, 2019]. However, this cloud-based paradigm faces critical challenges such as high reliance on network conditions, transmission latency, and significant risks to user privacy [Yao et al., 2022; Xia et al., 2024].

∗Corresponding Author: Xin Du and Shuiguang Deng.

With the growing computational capabilities of intelligent edge devices, deploying SR models on the edge becomes a promising solution. By enabling local inference, edgebased SR systems reduce communication overhead, improve real-time responsiveness, and provide inherent privacy advantages, as sensitive data remains local to the device [Xia et al., 2022; Yin et al., 2024]. However, current on-device SR models face potential challenges like:

High Memory Overheads. In standard SR tasks, item token sequences are used as the sole modality, requiring highdimensional embeddings to capture generalized representations for each item [Zivic et al., 2024]. This results in substantial memory footprints, particularly for platforms with extensive item catalogs. For instance, Amazon must manage over 350 million product embeddings for its recommendation system [Chen et al., 2022], leading to inefficient resource utilization and increased operational costs.

HighEnergyCosts. On-device SRmodels often operate on battery-powered mobile devices, such as smartphones, where sustainability is critical. Current SR models rely on artificial neural networks (ANNs) with large-scale architectures and full-precision computations, resulting in significant energy consumption. For example, deploying ANN-based models on devices like Google Glass [Venkataramani et al., 2016] consumes 0.15J per frame for video streams, which restricts the battery life of 2.1WH capacity to just 25 minutes, thereby degrading usability and user experience.

To address these challenges, we propose a Spike-wise Sequential Recommendation (SSR) model 1 , leveraging the computational paradigm of spiking neural networks (SNNs). This model is well-suited for deployment on intelligent edge devices featuring neuromorphic chips [Yao et al., 2024], which are specialized hardware designed to mimic the neural network architecture for efficient, low-energy computation. To overcome the limitations of dense embeddings in memory and computation, we introduce a neural encoding method that converts the original embedding table into spikebased representations, allowing SSR to process sequential features more efficiently. This method can diminish the storage limitations and accelerate computation compared to conventional dense embedding vectors. In addition, recent breakthroughs of deep SNNs in sequential tasks [Lv et al., 2024; Xing et al., 2024] shed light on the feasibility of developing on-device SR models due to their advantages of energy efficiency [Maass, 1997]. This study includes spiking filter modules that emulate the Fourier transform mechanism, enabling SSR to effectively process spike-wise signals and extract the dynamic user preferences from the asynchronous discrete spike trains.

1 https://github.com/AmazingDD/serenRec

To demonstrate the effectiveness of SSR, we conduct extensive experiments across real-world datasets. The results show that SSR achieves comparable or even better recommendation performance with much less computational energy cost compared to multiple ANN-based state-of-the-art (SOTA) baselines. SSR also generates sparse item representations to facilitate calculation, reduce memory footprint, and speed up inference, which is essential for on-device SR deployment [Yin et al., 2024]. To conclude, our contributions can be summarized as follows:

• This study first proposes an on-device SR model with deep SNNs, offering a cost-effective and energyefficient solution for enhancing user experience on intelligent edge devices.
• SSR generates a binary item representation, significantly reducing memory usage. It also incorporates spiking filter modules, effectively extracting individual preferences from asynchronous and sparse inputs.
• Extensive experimental results on five datasets validate that SSR can achieve recommendation performance on par with or even superior to seven SOTA SR models with much less energy consumption.

2 RelatedWork

On-Device Sequential Recommendation. Recently, ondevice SR systems have emerged to address users' demands for low-latency responses and heightened data privacy concerns [Yin et al., 2024]. Aerorec [Xia et al., 2024] introduces a self-supervised knowledge distillation method to mitigate the accuracy loss in compressed on-device recommendation models. OD-Rec [Xia et al., 2023] compresses the item embedding table by discrete compositional code learning to implement on-device recommendation efficiently. DIET [Fu et al., 2024] tailors SR models for each device to minimize bandwidth usage and storage consumption. Existing methods typically reduce inference latency and energy consumption through techniques such as compression [Yuan et al., 2020] and quantization [Li et al., 2023]. However, these approaches often degrade model performance by reducing feature expressiveness, particularly in scenarios with large-scale recommendation systems [Hou et al., 2023]. This motivates us to explore a novel on-device SR model that balances computational energy cost and recommendation accuracy better.

Recommendation with Spiking Neural Networks. Several researchers have investigated the feasibility of integrating SNNs into conventional collaborative filtering (CF) recommendation models. [Zhu et al., 2022] introduces spike-wise graphs to reduce the memory cost in graph-based CF models. [Ma et al., 2023; Agarwal et al., 2024] utilize the sparse encoding mechanism of SNNs to convert raw features into spike signals, thereby improving the CF model performance. These studies demonstrate the potential of SNNs to enhance feature representation and improve recommendation performance. However, most existing works focus on CF models and neglect SR tasks. Furthermore, no SNN-related SR algorithms have been designed specifically for neuromorphic chips [Ma et al., 2024], leaving SNNs' low-energy advantages under-explored for energy-aware edge device deployment. To bridge this gap, we propose SSR, the first ondevice SR model utilizing spiking neural networks to achieve energy-efficient sequential recommendation.

3 Preliminary

3.1 Spiking Neural Network

Leaky Integrate-and-Fire (LIF) [Maass, 1997] is one conventional spiking neuron to build SNNs, whose calculations can be described by a series of discrete-time equations:

where τ, V , and Vr denote the decay factor, threshold, and reset potential. Θ(·) is the non-differentiable Heaviside step function determining whether a spike is generated at time step t according to the membrane potential U(t) updated by input stimulus I(t). In this study, we use SN(·) to one LIF layer for brevity and introduce BPTT with surrogate functions [Dampfhoffer et al., 2023] to train SNNs on GPUs.

3.2 Fourier Transform

Discrete Fourier transform (DFT) has demonstrated its effectiveness in SR applications [Zhou et al., 2022; Shin et al., 2024]. As the input data of SR is one-dimensional sequences {xn}Nn=1 with the length of N, we only consider 1D-DFT in our study, which converts the original sequence into a sequence of complex numbers in the frequency domain by:

where W ≡ e -2πi N is a complex number as the twiddle factor, zk represents the signal with frequency 2πk/N. Through Equation (4), values in the sequence are decomposed into components of different frequencies. Since DFT is a one-toone mapping operation in the time and frequency domains, the frequency representation {zk}Nk=1 can be converted to the original feature domain by inverse DFT (IDFT):

Since item sequences can be treated as users' periodic behavior mixed with some unexpected actions (noise), DFT offers an efficient method to capture these time features [Du et al., 2023]. This study uses the Fourier transform paradigm to process and filter noisy spikes in SSR. We denote DFT and IDFT by F(·) and F -1 (·), respectively.

4 Methodology

4.1 Problem Statement

We first define U and V to represent the set of users and items, respectively, where u ∈ U denotes a user and v ∈ V denotes an item. The number of users and items are |U| and |V|, respectively. Sequential recommendation relies on the previous interactions in a short period to generate the next-item recommendation. Let x = {v1, v2, ..., vN} ∈ X, where N is the number of interactions, and vn is the n-th item that the user u2 has interacted with in the chronological order. For convenience, we use xj:k to denote the subsequence, i.e., xj:k = {vj , ..., vk}, where 1 ≤ j ≤ k ≤ N.

Based on the above notations, we define the task of the SR as to predict the next item vN+1 that the user is most likely to interact with at the (N + 1)-th step, given the contextual item sequences x = {v1, v2, ..., vN} of a user u. We set y as the ground truth of the following user action, i.e., y = vN+1 ∈ Y. Hence, the learning objective of implementing SR on resource-constrained edge devices is to minimize the ranking loss L over data distribution D = (X , Y):

where C(·) refers to the total cost of using a specific SR model for inference, e.g., energy consumption, inference latency, etc., and b is the specific limitations required by the devices.

4.2 SSRModel

As depicted in Figure 1, we introduce the architecture of SSR, including five modules: embedding layer, stimulus encoder, spiking filter layer, PSFFN layer, and prediction layer.

2 When the user is anonymous, sequential recommendation tasks degenerate into session-based recommendation tasks.

Embedding Layer. Similar to previous study [Yue et al., 2024], an item embedding matrix EV ∈ R|V|×D is leveraged to project each item token vn in the sequence x to a highdimensional representation vn ∈ RD . Given one item sequence x, we can obtain a new sequence embedding matrix X ∈ RN×D with look-up operations:

Although using non-spiking values like Equation (7) as inputs of SNN-based models is pretty ordinary [Yao et al., 2023], it is more logical to utilize spikes as the input of SNNs like the brain trades in the global currency of the spike, bringing potential computational efficiency and sparse storage.

As depicted in Figure 2, one dense embedding table can be converted into T sparse binary tables by the temporal encoding mechanism of spiking neurons (In this study, N should always be ensured to be divisible by T). Due to the high sparsity and huge memory usage gap between floating-point and binary values (e.g., 32-bit vs. 1-bit), encoding the original embedding table with spiking neurons can enhance computational efficiency and diminish redundant memory usage. Therefore, we feed features from the embedding table, like a gray-scale image, to a layer of spiking neurons repeatedly over T time steps. Then, we get the spike-wise sequence embeddings X∗ ∈ IT×N×D containing only binary values:

where T, N, and D are the degree of time step, sequence length, and hidden factor dimension.

Stimulus Encoder. The raw spike trains derived from Equation (8) offer a sparse representation of each item token but fail to capture sequential features. To address this limitation, we propose an encoder module within SSR, designed to aggregate spike-level signals and generate stimulus representations encompassing sequential features. This module comprises two components: (1) The serial presentation encoder is implemented as a linear transformation moving block. It captures cumulative spike information across temporal steps in the sequence, effectively extracting long-term interests. (2) The parallel presentation encoder acts as a global-level aggregator, leveraging another weight matrix to perform weighted summations over items in the sequence at each time step, thereby capturing point-level preference patterns. The stimuli generated by these two encoders are aggregated to form a new dense stimulus that preserves the sequences' temporal and contextual patterns, which will then be fed into a LIF layer SN(·) to construct the spike-wise encoded sequential features H ∈ IT×N×D for further model learning. Considering the primary focus of this study is designing a feasible SNN-based model to complete on-device SR tasks, we have proved that our stimulus encoding method fits well in most scenarios.

Spiking Filter Layer. Inspired by [Zhou et al., 2022], filtering operation can be utilized to convert each dimension of features into another learnable feature space and reconstruct the sequence representations with less noisy signals.

Given the input Hlt ∈ IN×D for the filter layer in the lth block at time step t (l ∈ [1,L], t ∈ [1, T]; when l=1, Hl=H), we apply 1D-DFT F(·) along the sequence dimension N of Hl to convert it to frequency domain and then multiply a learnable matrix Wl , denoted as:

where ⊙ is the element-wise multiplication. ˜Hlt can be adaptively optimized using gradient descent to represent an arbitrary filter in the frequency domain. Finally, the 1D-IDFT F -1 (·) is adopted to transform the modulated spectrum ˜Hlt back to the original domain, reconstructing new sequential representations as the output of the entire filter layer:

These operations allow useless spikes from Hlt to be effectively filtered as noise. Following [Kang and McAuley, 2018]. We add the skip connection [Wang et al., 2021] to avoid gradient vanishing and unstable training issues.

However, the above operations are feasible for ANNs on GPUs yet unsuitable for SNNs on neuromorphic chips since ˜Hlt is a complex tensor that is an illegal representation in neuromorphic computing logistics. To tackle this problem, we exploit the successive multiplication representation, emulating DFT in SNN layers due to DFT's linear transformation [Arsalan et al., 2023]. We first rewrite Equation (4) according to the Euler's method as:

where n and k take values ranging from 1 to N. When expanding xn to an input vector, Equation (11) can be written in matrix form like:

where WR and WI are the real and imaginary coefficient matrices, whose individual coefficient values can be calculated using the following equations:

Algorithm 1 Model Inference of SSR.

Input: Input sequences x, top value k

Output: Top-k recommendation list Pk

• 1: Query spike-wise representation X∗ with x.
• 2: Encoding X∗ to H.
• 3: for all filter block l ∈ {1, ...,L} do
• 4: Learnable 1D-DFT: ˜Hl = F(Hl ) ⊙Wl .
• 5: 1D-IDFT: ˜Fl = F -1 ( ˜Hl).
• 6: Convert ˜Fl to spikes with SN(·).
• 7: end for
• 8: Densify: ˆHL ←Linear(˜FL).
• 9: Computing preference scores P with ˆHL and X∗ .
• 10: Sort P in a descending order.
• 11: Cut out top-k items from P to form Pk.
• 12: return Pk

We can then substitute F(Hlt ) in Equation (9) with a series of spike-wise operations like:

where the convolution operation Conv simulates the integration of real and imaginary parts as the complex tensor. Similarly, the IDFT operation in Equation (10) can also be modified to spike-wise form inversely, denoted as ˜ F -1 (·), and we denote the binary output of the l-th filter layer after implementing the spike-wise IDFT operation as ˜Flt .

PSFFN Layer. For the point-wise spiking feed-forward network (a.k.a. PSFFN) layer in the l-th block at time step t, we integrate LIF with a two-layer MLP to project the nonlinear features extracted from the spiking filter layer into a higher-dimensional space to improve the modeling ability of user actions in the hidden dimension. The computation of PSFFN is defined as:

where W1, W2 are both learnable weight matrices. Skip connection operations are also incorporated into this component for training stability.

Prediction Layer. Given the spike-wise hidden features ˆHLt at time step t from the last L-th block at position n, it will first be converted into a dense vector as ˆhLt,n ∈ RD via linear transformation in the prediction layer. Then, the preference score for the next item y over V given sequence x can be calculated by:

where bo ∈ R|V| is an additional bias term indicating the deviation of items v ∈ V from the global perspective. We adopt point-wise cross-entropy loss to optimize the model parameters θ by minimizing the following objective:

We summarize the inference process of SSR in Algorithm 1. In addition, we have elaborated on the time complexity analysis of SSR and the effectiveness of the spiking filter module .

5 Experiments

5.1 Experimental Settings

Datasets. Five public datasets collected from various platforms are selected to evaluate the efficacy of SSR. Their corresponding statistics are summarized in Table 1, sorted by density. Following [Zhou et al., 2022], we group the records by users or sessions, sort them by time in ascending order, and adopt a 5-core strategy for all datasets to ensure each user and item has at least five interaction records.

Metrics. As for the recommendation performance, we follow [Yin et al., 2023] and calculate the Hit Rate (HR), Normalized Discounted Cumulative Gain (NDCG), and Mean Reciprocal Rank (MRR) after generating the Top-k recommendation list with a full-ranking protocol. Higher values indicate better performance for all metrics. For energy cost, we evaluate the number of operations (OPs) [Xing et al., 2024] and theoretical energy consumption gauged in joules (J).

Baselines. We compare SSR with multiple SOTA SR baselines with two categories: (1) RNN-/CNN-based SR models: CASER [Tang and Wang, 2018], GRU4REC [Hidasi et al., 2015] and NARM; (2) Transformer-based SR models: SASREC [Kang and McAuley, 2018], FMLP [Zhou et al., 2022], BSAREC [Shin et al., 2024], and LRUREC [Yue et al., 2024].

Implementation Details. We use the time-aware and userlevel split-by-ratio strategy [Sun et al., 2022] to split the whole dataset, where the last 20% of the total item sequences is the test set. To make a fair comparison, all model hyperparameters are searched with the TPE [Bergstra et al., 2011] strategy within 20 trials with Optuna [Akiba et al., 2019]. By default, we implement all models with Torch and use Adam optimizer with the 10-3 learning rate. The embedding dimension for each item is 64, and the time step size T for LIF neurons is 4.

5.2 Performance Evaluation

RecommendationPerformance. Table 2 lists the results of our proposed SSR compared with all other baselines on various evaluation metrics across different datasets. We conclude from the observations that SSR achieves comparable performance across all metrics and datasets, with an average performance gap of 1.06% compared to the best method. Despite the data flow inside SSR being binary spikes, SSR maintains the effectiveness of capturing useful sequence characteristics, just as the floating-point operation does. Notably, SSR's performance gains are more significant on dense datasets. In contrast, they are modest on sparse datasets since dense sequences contain more sequential embedding knowledge fed into LIF neurons, thereby generating more spike information to communicate among layers and achieve better performance. Besides, SSR often performs better in ranking-related metrics. For instance, although BSAREC achieves a higher average hit rate, approximately 2.95% greater than SSR on the Steam and Arts datasets, SSR outperforms BSAREC on the NDCG metric by about 2.28%. This suggests that, while SSR may not always accurately identify all ground truth next items from users' previous interactions, it better captures sequential patterns, placing the ground truth items in higher positions within the ranking list. Meanwhile, by examining the critical difference diagram depicted in Figure 3, we can roughly categorize all the methods we have employed into three tiers, and it is a pleasant surprise that our SSR ranks with the top tier, demonstrating that regardless of the data scenario, SSR consistently demonstrates strong and stable performance, making it less likely to yield poor results when used for recommendations.

Energy Cost. We evaluate the inference energy efficiency to illustrate the potential of SSR to enhance user experience by prolonging mobile phone usage time while maintaining effective recommendation performance. We assume running SSR on a 45nm neuromorphic hardware [Horowitz, 2014] and other baselines on GPUs, since SNNs can demonstrate low computing energy costs when deployed on neuromorphic chips, and GPUs are the most suitable platform for executing ANNs. Since different baselines vary in computational complexity due to differences in parameters and architectures, directly comparing their energy consumption with SSR would be unfair. Hence, we devise an ANN-based variant called SSR-ANN, referring to SSR, which utilizes the standard DFT/IDFT computation, replaces all spiking neurons with ReLU 3 , removes the stimulus encoder, and keeps other parameters the same as SSR's.

As listed in Table 3, SSR exhibits a notable energy cost reduction compared to its ANN variants, with an average decrease of approximately 59.43% across all datasets, and the computational operations are reduced by over 50%-such intriguing benefits position SNNs as an attractive choice for energy-efficient solutions for the on-device SR tasks 4 .

3 LIF neuron in SNN is an unbiased estimator of ReLU activation function over time [Rueckauer et al., 2017].

4 In practical applications, beyond computational costs, SSR executed on a neuromorphic chip can eliminate the additional energy

5.3 Efficiency Evaluation

Memory Usage. We vary the dimensionality of item embeddings from 50 to 250 to evaluate the compression effect of LIF neurons on the original dense embeddings. Observations in Figure 4 reveal that the parameter size of the conventional model increases linearly with the embedding dimension. In contrast, the embedding size regulated by the LIF layer encoder is substantially reduced, achieving a maximum reduction rate of 99.36%. Moreover, as the embedding dimension grows, the size follows a logarithmic growth pattern. This demonstrates that spike-wise embedding effectively compresses and retains essential information, reducing computational memory overheads for resource-constrained edge devices via sparse tensor computation.

consumption associated with data movement between the chip and memory. Furthermore, neuromorphic chips offer significantly lower latency-about 200 times less-than conventional chips. For instance, Speck [Yao et al., 2024] achieves a latency of less than 0.1 ms when implementing SNNs on-chip. In contrast, the latency increases to 24.7 ms when the SNN is not implemented on-chip.

Model Robustness. We conduct experiments by randomly replacing different percentages of items in sequences with randomly selected fake items and retraining the model using the corrupted sequences as input to evaluate the robustness of SSR against data noise issues. The noise ratios varied from 0% to 20%, with increments of 5%. SASREC and NARM are the target models for comparison, as they feature representative neural architectures within their respective baseline categories. We adopt relative metrics, i.e., Relative (Rel.) HR@10 and Rel. NDCG@10, to assess the performance trend of different models w.r.t different levels of noise perturbation. Figure 5 exhibits the performance degradation under different noise levels, indicating the potential of SNNs in addressing data noise issues. In the sparser Arts dataset, while SASREC and NARM initially perform well under low noise levels, their performance degrades significantly when exposed to 15% noise. In contrast, SSR demonstrates greater robustness to noise compared to these models. Even with 20% noise, SSR maintains a relative HR@10 of 98.92% and an NDCG@10 of 98.18%. In the relatively denser Movielens dataset, SSR's performance is comparable to that of other models when the noise degree is less than 15% and then declines more slowly when noisier items are included. The superiority of SSR might be attributed to SNNs' advantage in capturing sparse features. When item sequences are sparse and have low similarity, introducing noise can easily lead to over-fitting in ANN-based models. However, SNNs' sparse computational characteristics can effectively mitigate this issue. When the sample is relatively dense and similar, the noise impact can be alleviated through knowledge transfer between samples, resulting in minimal performance differences among these models. Nevertheless, when the noise level is sufficiently high, causing a rapid decrease in sample similarity, the advantages of SNNs become more evident.

Long Sequence Scenarios. We evaluate the performance consistency of SSR across SR tasks with varying task complexities by altering the maximum length of the input sequences, as the high-order sequential dependencies introduced by long item sequences pose challenges for models to capture user preferences accurately. Similarly, we select SASREC and NARM as baselines to compare their performance with SSR and categorize sequences into three groups based on the sequence length. As illustrated in Figure 6, the models generally exhibit higher predictive accuracy for shorter input sequences, as leveraging more interaction histories can extract more valuable information through SR models. Meanwhile, SSR consistently demonstrates more excellent stability than the other models. In sparser Arts data scenarios, SSR outperforms other baselines, achieving a higher average HR@10 improvement rate than the dense Movielens scenario, with an approximate increase of 17.31%. This may be attributed to the spike-wise signals propagated within the SSR model, which are better at filtering out the items in an input sequence that are most relevant to the prediction. This reduces the impact of noise on the results, thereby more effectively uncovering users' latent preferences under long sequence conditions.

5.4 Hyper-Parameter Analysis

Time Step. Time steps T dictate the complexity of SSR, and a higher number of time steps leads to an increased energy cost. As depicted in the left part of Figure 7, the HR@10 of SSR shows a notable improvement of approximately 15% when the number of time steps increases from 1 to 4. Beyond this point, the performance gains plateau, suggesting that the membrane potential of LIF neurons in SSR has stabilized and can generate consistent spike trains, with no additional time steps needed for stabilization. Hence, setting T=4 provides a practical solution for achieving a better cost-accuracy tradeoff in SSR during inference.

Decay Rate. Decay rate τ determines the frequency of information communication between layers in SSR by controlling the firing rate of neurons. A lower decay rate indicates more spike transmission. The right part of Figure 7 shows that HR@10 remains relatively stable at lower decay rates but experiences a sharp decline of up to 40% once the decay rate exceeds 0.5, indicating that higher decay rates hinder the model's ability to capture relevant information, leading to the loss of crucial temporal details, which ultimately degrades HR performance. Meanwhile, lower decay rates often cause LIF neurons to fire spikes excessively, leading to unnecessary energy costs with minimal performance improvements. Therefore, a moderate decay rate like 0.5 can better balance the cost and performance of SSR.

6 Conclusion

In this paper, we proposed a novel on-device SR model called SSR, leveraging SNNs to achieve energy-efficient and sparse computing. SSR transforms dense item embeddings into sparse spike-wise representations, effectively capturing dynamic user preferences while reducing memory and computational overheads. Extensive experiments on diverse realworld datasets demonstrate that SSR achieves comparable recommendation accuracy to ANN-based baselines while significantly improving theoretical energy efficiency.

Acknowledgments

The work of this paper is supported by the National Key Research and Development Program of China under Grant 2022YFB4500100, the National Natural Science Foundation of China under Grant 62125206, the Zhejiang Provincial Natural Science Foundation of China under Grant No. LD24F020014, the National Key Research and Development Program of China No. 2024YDLN0005, and the Regional Innovation and Development Joint Fund of the National Natural Science Foundation of China No. U22A6001.