Multi-merchant user behavior deep learning analysis method

Abstract

The invention relates to the technical field of e-commerce, in particular to a multi-merchant user behavior deep learning analysis method, which comprises the steps of collecting interaction data of each merchant end, calculating a gradient based on a local learning model, packaging slices and uploading the slices to a cloud end; aggregating gradients, constructing a behavior relation graph and generating a causal tensor, and inputting the causal tensor and the graph domain multi-scale features into a time sequence embedding model to obtain time embedding; generating commercial tenant high-dimensional pulse vectors through random projection and binary mapping, and aggregating the commercial tenant high-dimensional pulse vectors into cross-commercial tenant vectors; executing a generative reverse process on the cross-merchant vector according to a noise strategy to obtain a prediction vector; the prediction vector and time are embedded and mapped into an energy matrix, an action vector is sampled through quantum optimization, and the action vector and a cross-merchant vector are input into a reinforcement learning network to output a recommendation decision; and generating an update gradient according to user clicking and payment feedback, and returning the update gradient to the merchant end to form a self-calibration closed loop. According to the method, cross-merchant collaborative recommendation is realized on the premise of not exposing original data, and cold start recall and real-time conversion rate are improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of electronic commerce, and in particular to a multi-merchant user behavior deep learning analysis method. BACKGROUND

[0002] Under the platform economy, a single user often appears in the operation links of multiple e-commerce or service providers. If each merchant is independently modeled, the user portrait is fragmented, and the recommendation strategy is prone to conflict, resulting in a double decline in click-through rate and conversion rate. To this end, the industry attempts to share interest information using federated collaborative filtering or cross-domain matrix decomposition, but there are still the following shortcomings: 1. Existing methods require the transmission of high-dimensional features or intermediate activations; large amounts of data and sensitive behavior are easily exposed. 2. It relies heavily on static weights or single-scale graph convolution, making it difficult to capture instant hotspots such as flash sales and live broadcasts. 3. The cloud unified training period is long, and local interest changes cannot be written back in real time, resulting in a lag in the recommended results. The root cause of these defects is: lack of gradient-level privacy collaboration mechanism; the graph structure only considers first-order adjacency; the training-inference chain is broken in one direction. SUMMARY

[0003] In view of the many problems existing in the prior art, the present application provides a multi-merchant user behavior deep learning analysis method, which batches the user interaction gradient and slices it for upload; homomorphically aggregates the gradient, constructs a user-goods-session-context supergraph, generates a binary pulse vector after temporal and spatial feature extraction through causal intervention and multi-scale wavelet, and sums across merchants to obtain a unified state. The state is reversely generated into future interest through noise scheduling diffusion, mapped into an energy matrix placed in a quantum annealer to find the global action, and then fine-tuned by reinforcement learning combined with real-time feedback. The feedback gradient is backflowed and updated synchronously to achieve privacy-safe, real-time adaptive collaborative recommendation.

[0004] A multi-merchant user behavior deep learning analysis method, comprising the following steps:

[0005] Collecting behavior data related to user interaction at each merchant end, calculating a gradient vector based on a local learning model, and encapsulating the gradient vector as a gradient slice and uploading it to the cloud;

[0006] Performing aggregation on the gradient slices in the cloud to obtain aggregated gradient data, constructing a relationship graph describing user behavior based on the aggregated gradient data, and generating a causal representation tensor based on the relationship graph, inputting the causal representation tensor and the multi-scale features of the graph domain into a time sequence embedding model to obtain a time embedding representation; generating a high-dimensional pulse vector corresponding to each merchant using random projection and binary mapping, and further aggregating the high-dimensional pulse vectors corresponding to each merchant to form a cross-merchant high-dimensional vector;

[0007] A generative reverse process is performed on the cross-merchant high-dimensional vector according to a preset noise strategy to obtain a prediction vector. The prediction vector and the time embedding representation are mapped into an energy matrix. The action vector is obtained through quantum optimization sampling. The action vector and the cross-merchant high-dimensional vector are then input into the reinforcement learning network to output the recommendation decision data.

[0008] An updated gradient vector is generated based on user feedback corresponding to the recommended decision data, and the updated gradient vector is sent back to the merchant end to update the local learning model to form a self-calibration closed loop.

[0009] Preferably, the behavioral data includes click sequences, dwell time sequences, payment event sequences, return event sequences, and customer service conversation text sequences. Normalization, discretization, and word embedding processing are performed on the behavioral data in sequence, and the processed data are used to calculate the gradient vector in batches.

[0010] Preferably, the uploaded gradient slices are smoothed using a weighted moving average method to obtain the aggregated gradient data.

[0011] Preferably, the relationship graph is a hypergraph comprising user nodes, session nodes, product nodes and context nodes, and the edge weights of the hypergraph are determined by the time difference of the interaction events and the event type coding.

[0012] Preferably, the causal representation tensor is generated by performing an intervention operation on the node attributes of the hypergraph, calculating the numerical difference before and after the intervention and writing it into the diagonal of the tensor.

[0013] Preferably, in the relationship graph, a bipartite subgraph consisting of user nodes and product nodes is first extracted; multi-order power operations are performed on the normalized Laplace matrix of the bipartite subgraph, and the convolution coefficients of each order are calculated in combination with the exponential decay kernel; the convolution coefficients of different orders are spliced ​​in sequence to obtain multi-scale features of the graph domain.

[0014] Preferably, the time series embedding model is composed of a recursive neural network and a neural ordinary differential equation connected in series, wherein the output of the recursive neural network serves as the initial value of the neural ordinary differential equation.

[0015] Preferably, the high-dimensional pulse vector is obtained by multiplying the time embedding representation with a random projection matrix, performing a binarization mapping through a hyperbolic tangent function and taking a sign function, and the resulting binary vector constitutes the high-dimensional pulse vector.

[0016] Preferably, the generative reverse process determines a noise scheduling table according to the variance information of the cross-merchant high-dimensional vector, and periodically introduces topological chaos Monte Carlo annealing in the reverse iterative process.

[0017] Preferably, the quantum optimization sampling is completed on a quantum annealing processor, and the sampled action vector and the cross-merchant high-dimensional vector are jointly input into the reinforcement learning network, wherein the reward signal of the reinforcement learning network is calculated based on user click feedback and payment feedback.

[0018] Compared with the prior art, the advantages and beneficial effects of the present invention are:

[0019] The present invention uses gradient slicing homomorphic aggregation technology to achieve cross-merchant sharing of interest information without exposing the original data, solving the privacy and bandwidth bottlenecks.

[0020] The present invention realizes the dynamic capture of sudden hot spots and long-chain collaboration through high-order hypergraph causal intervention + multi-scale spectral wavelet technology, and solves the instability problems of cold start and pulse traffic.

[0021] The present invention achieves accurate prediction of multi-modal future interests by combining a generative reverse process with topological annealing technology, overcoming the single-modal collapse defect of the fixed weight model.

[0022] The present invention achieves global optimal jump and local rapid adaptation through quantum annealing sampling prior + reinforcement learning fine-tuning technology, avoiding the traditional sorting model from falling into local extreme values.

[0023] The present invention achieves minute-level parameter synchronization through bidirectional gradient closed-loop technology, eliminating the problem of model time lag. BRIEF DESCRIPTION OF THE DRAWINGS

[0024] Figure 1 Schematic diagram of the process of the present invention;

[0025] Figure 2 Schematic diagram of cloud-based core reasoning and closed-loop update in the present invention. DETAILED DESCRIPTION

[0026] Hereinafter, embodiments of the present disclosure will be described with reference to the accompanying drawings. However, it should be understood that these descriptions are merely exemplary and are not intended to limit the scope of the present disclosure. In the following detailed description, for ease of explanation, many specific details are set forth to provide a comprehensive understanding of the embodiments of the present disclosure.

[0027] like Figure 1-Figure 2 As shown, a multi-merchant user behavior deep learning analysis method includes the following steps:

[0028] Collect behavioral data related to user interactions at each merchant end, calculate gradient vectors based on the local learning model, encapsulate the gradient vectors into gradient slices, and upload them to the cloud;

[0029] In deep learning analysis of multi-merchant user behavior, this invention first generates trainable gradient slices in real time for each merchant's user interaction stream, enabling subsequent cross-merchant joint modeling. The overall principles of this step can be divided into three layers: data collection – characterization, gradient derivation – segmentation, and upload collaboration – access control. The following describes the technical implementation mechanism, key results, and examples.

[0030] Data collection and characterization: Each merchant deploys a lightweight data collection module and establishes timestamp queues for click sequences, dwell time sequences, payment event sequences, return event sequences, and customer service conversation text sequences. The collection module pulls the latest interaction events at a fixed time granularity through the local buffer. For structured events (clicks, payments, returns), numerical encoding is directly used; for unstructured text, the built-in subword segmentation table on the calling end maps the text stream to a fixed-length word vector and then calculates the weighted average feature. This process does not involve deep models and only completes lightweight preprocessing to ensure real-time operation within the acceptable range of edge device computing power.

[0031] Gradient derivative - block, the default local learning model uses a shallow feedforward network with batch normalization layer and residual connection. This model only maintains private parameters θ on each merchant side. Whenever the buffer accumulates a batch of samples (the batch size is set to a fixed integer in the embodiment section of the manual), fast backpropagation is called to obtain the gradient. The core formula is:

[0032]

[0033] Where g represents the first local gradient vector, B is the sample batch size, and x i is the i-th preprocessed sample vector, y i is the corresponding label or pseudo label, represents the derivative of the parameter θ, is the local loss function (cross entropy loss is used in the embodiment). The obtained g is L2 normalized to suppress the amplitude offset caused by the difference in the number of samples between merchants, and then split into a fixed-length sub-vector sequence. The setting of the split length takes into account the cloud accelerator throughput and the maximum load of the network packet. Each sub-vector is attached with the acquisition timestamp and gradient batch number, which are combined into a gradient slice metadata header, which is then packaged in series with the sub-vector body into an uploadable data block.

[0034] Upload collaboration - access, gradient slices are pushed using a persistent link. After receiving, the cloud verifies header information using a hash to determine duplication and sequence integrity. Only slices that pass the verification are entered into the global aggregation queue; slices that fail the verification are entered into the retransmission queue on the merchant side. Because slice encapsulation ensures the consistency of sub-vector lengths, the cloud completes aggregation mapping based on the natural arrival order, eliminating the need for alignment operations.

[0035] This invention keeps the number of local model layers within the firmware's supported range. Experiments show that the average gradient overhead per batch is less than ten milliseconds per merchant, ensuring no impact on front-end service responsiveness. Gradient vectors are uploaded instead of the original behavior sequence, reducing the risk of direct leakage of sensitive data while providing sufficient parameterized information for subsequent causal inference. The slicing mechanism allows packet loss retransmissions to be reduced to the sub-vector level, ensuring that even the loss of a single slice does not affect the aggregation of remaining sub-vectors in the same batch.

[0036] In the verification scenario of a fresh food e-commerce platform and a digital content platform, the batch size is set to 256 and the sub-vector length is set to 128. The fresh food merchant generates an upload event per second, and the digital content merchant generates an upload event every 0.5 seconds due to high browsing volume. After running according to the above process for 24 hours, the cloud has received a total of 5 million gradient slices from the two types of merchants, and the packet loss rate is controlled within one thousandth. After calculation, the normalized gradient distribution is near the zero center, and the variance difference is less than one percentage point, which meets the expectations of cross-merchant merging. The experiment verifies the stability of this step under multi-source traffic and unbalanced business load.

[0037] Preferably, the behavioral data includes click sequences, dwell time sequences, payment event sequences, return event sequences, and customer service conversation text sequences. Normalization, discretization, and word embedding processing are performed on the behavioral data in sequence, and the processed data are used to calculate the gradient vector in batches.

[0038] To ensure consistent input for deep learning analysis of multi-merchant user behavior across heterogeneous business scenarios, this paper first implements a unified feature normalization process for the merchant-collected click sequences, dwell time sequences, payment event sequences, return event sequences, and customer service conversation text sequences. This process sequentially completes normalization, discretization, and word embedding, outputting batch tensors that can be directly used for gradient differentiation. The following describes this process from four perspectives: implementation principle, specific operations, technical effects, and examples.

[0039] Normalization uses interval linear mapping to compress each numerical feature into a closed interval between zero and one. The timestamp of each click event in the click sequence and the page ID form a two-dimensional vector. By performing minimum-maximum scaling on the time dimension, the page ID is integerized. The dwell time sequence is also mapped to the zero-to-one interval after logarithmic compression. The amount fields involved in payment and return events are processed jointly using interval scaling and logarithmic smoothing. At this stage, only the sentence length and punctuation ratio normalization indicators are calculated for the customer service conversation text sequence. The core function of the above operations is to eliminate the differences in the absolute scale of the same indicator among different merchants, making the subsequent model gradient distribution more stable.

[0040] The discretization process performs segmented encoding on the normalized behavioral numerical stream. The click frequency is divided into five segments according to fixed intervals within one hour; the length of stay is set to three thresholds in the logarithmic domain; the payment amount is symmetrically segmented with the merchant's average daily customer unit price as the center; return events are divided into two segments based on the return application status; and the sentence length indicator in the customer service text is divided into three segments based on the mean sentence length. The segmented encoding process outputs a set of sparse integer indexes to facilitate subsequent embedding layer retrieval. This discretization strategy shares the segment upper limit and uses the same segment width among different merchants, ensuring that the output index space of different merchants is completely consistent, thereby improving the consistency of feature mapping across merchants.

[0041] Word embedding processes the semantic information of customer service conversation text through three steps: subword segmentation, embedding matrix, and average pooling. The subword segmentation model uses a fixed vocabulary and can be loaded offline on the client side, eliminating the need for online maintenance of large-scale natural language models.

[0042] The subword ID is input into an embedding matrix of size E×d (E is the vocabulary size, d is the embedding dimension), and the embedding vector is output and averaged at the sentence level to obtain the customer service text semantic vector v tezt To keep the dimension consistent with numerical discrete index, v tezt Append to the tail of the sparse index tensor and treat it as a continuous variable when calculating the gradient. After completing the three preprocessing steps, all features are concatenated into a dense vector x of length D. Assemble batch tensors with batch size B Input the local learning model. The model uses a three-layer feedforward network with decreasing hidden layer width and batch normalization layer. Each forward propagation outputs a prediction vector For classification scenarios, this paper adopts the cross entropy loss function:

[0043]

[0044] where y i For labels, is the predicted value. Derivative the model's trainable parameter θ to obtain the batch gradient vector:

[0045]

[0046] g is L2 normalized:

[0047]

[0048] Where ∈ is the anti-zero threshold. The normalized gradient vector is divided into a fixed-length sub-vector sequence {g1, g2, ..., g k The batch number and sampling timestamp are appended to each sub-vector to form a gradient slice header, and the gradient slice is generated through binary serialization.

[0049] Gradient slice uploads are pushed using a persistent connection. After receiving data on the cloud, it is sorted by batch number, enabling direct vector-level aggregation without retracing the original data. This data abstraction reduces merchants' concerns about data security and complies with cross-merchant privacy isolation principles.

[0050] The core technology's effectiveness is reflected in three key areas: First, by unifying the normalization intervals and segmentation thresholds, behavioral data from multiple merchants is mapped to the same feature distribution, enabling parameter sharing in the batch normalization layers required for cloud-based joint model training. Second, gradient-level slice transmission replaces transmission of raw behavioral sequences, reducing bandwidth and privacy risks. Finally, customer service text is embedded at the subword level and used in gradient derivations, adding semantic context to purely structured behavioral sequences and significantly improving the interpretability of subsequent causal tensor inference.

[0051] In the embodiment, three e-commerce merchants and one digital content merchant were selected in the multi-merchant scenario experiment. Each merchant uploads the gradient slices to the joint server according to the process of this article. The server aggregates the gradient vector once a minute and updates the global model, and the training lasts for twenty-four hours. On the evaluation set, compared with the control group that only uses structured event sequences, the solution of the present invention improves the AUC indicator by 3%. The experiment of controlling the randomly distributed slice length shows that the fixed-length slicing strategy can reduce the server-side decoding time by about 10% under the same bandwidth, proving the network optimization effect of the block consistency strategy.

[0052] Aggregate gradient slices in the cloud to generate aggregated gradient data. A relationship graph describing user behavior is constructed based on the aggregated gradient data, and a causal representation tensor is generated based on the relationship graph. This causal representation tensor and the multi-scale features of the graph domain are input into a temporal embedding model to obtain a temporal embedding representation. High-dimensional impulse vectors corresponding to each merchant are generated using random projection and binarization mapping, and the high-dimensional impulse vectors corresponding to each merchant are further aggregated to form a cross-merchant high-dimensional vector.

[0053] Aggregate gradient data to build a user behavior relationship graph. The gradient slices uploaded by the merchant are decoded in the cloud and first batch spliced ​​to obtain the complete gradient tensor. Let the gradient tensor be Where N represents the number of merchants and P represents the local model parameter dimension. To address the differences in sample size between merchants, the present invention performs batch normalization on G along the merchant dimension, shifting the mean to zero and unifying the variance to unity to eliminate gradient amplitude bias. A confidence-weighted averaging strategy is then used to obtain the aggregated gradient vector:

[0054]

[0055] where g (i) is the gradient vector of the i-th merchant, w iTo ensure that poor network merchants are not affected by packet loss, a reliable weight is calculated according to the upload batch integrity rate. The aggregated gradient vector is projected into the relationship graph node weight domain through a linear mapping, which is used to measure the sensitivity of the node to the overall loss change. The node set The four types of entities are composed of users, sessions, commodities and contexts, and the edge set epsilon is composed of the time sequence interaction between two adjacent entities. To efficiently organize multi-source high-order interaction, the invention uses hypergraph modeling. Each hyperedge contains a user node, a commodity node and a group of session nodes and context nodes associated with it. The hyperedge weight is defined by the following formula:

[0056]

[0057] where g agg [v] represents the sensitivity component of node v on the aggregated gradient vector, and sigma (·) represents a nonlinear compression function. The weight serves as an important basis for applying intervention in subsequent causal inference.

[0058] Causal representation tensor generation: to depict the potential causal effect in the user path, the invention performs intervention analysis based on "do-calculus" on the relationship hypergraph. The specific operation is: separate the key attributes of each node one by one, set another value by force, and then propagate the gradient again to record the global loss increment. The loss increment brought by each node intervention is used as the node causal effect measure, and filled into the three-dimensional tensor The third dimension K represents the discrete level of intervention intensity. The same experimental setting is used for intervention of the same type of node to ensure reproducibility when comparing across merchants.

[0059] The causal representation tensor is used for weight modulation in subsequent graph domain wavelet convolution, and is also reflected in tensor compression before random projection, providing a unified significance prior for the embedding results of different merchants.

[0060] Graph domain multi-scale feature extraction: to preserve local structure and global topology information, the invention uses spectral graph wavelets. Take the bipartite subgraph (user-commodity) as an example, its normalized Laplacian matrix is denoted as L. The multi-scale wavelet kernel is defined as:

[0061] Ψ m = L m / 2 exp(-alpha L)

[0062] where m is the scale order, and alpha is the attenuation coefficient. Apply Ψ m to the node feature vector h to get the convolution result h m of scale m, that is, h m = Ψ ms Select three non-adjacent scale orders to form the multi-scale coefficient h=[h1||h3||h5]. This multi-scale coefficient can capture the behavior patterns of different wavelengths without adding a large number of parameters.

[0063] The time series embedding model adopts a cascade structure of recursive neural network (hereinafter referred to as RNN) and neural ordinary differential equation (hereinafter referred to as NODE). RNN preliminarily encodes the multi-scale coefficient sequence and outputs the hidden state s t . s t As the NODE initial value, the NODE evolution equation is defined as:

[0064]

[0065] where z(0) = s t ; f(·) is a non-autonomous vector field with learnable parameters φ. The classic Dormand-Prince solver integrates over a fixed time interval to obtain the time embedding representation z final Time embedding preserves the intrinsic dynamic information of causal representation and wavelet multi-scale features in the continuous time domain, and is smoother and more resistant to noise than discrete time series coding. Random projection and binarization To further suppress differences between merchants and compress communication volume, the time embedding vector is projected onto a high-dimensional binary hypersphere. Projection matrix (D h Much larger than d z ) is generated offline according to the Rademacher distribution and shared among all merchants. The high-dimensional vector calculation formula is:

[0066] h=sign(tanh(Pz final ))

[0067] Where sign(·) represents the sign function, and tanh(·) introduces nonlinear compression. The obtained h has three advantages: approximate orthogonality, fixed binary value, and easy homomorphic summation. Cross-merchant high-dimensional vector aggregation The cloud directly adds the high-dimensional pulse vectors from all merchants for each time slice to obtain a cross-merchant high-dimensional vector This vector can be used as a unified input for downstream diffusion generation and quantum optimization modules without further decoding. Because the binarization process ensures one-way irreversibility, H does not contain any information that can be traced back to the original interaction sequence, meeting privacy isolation requirements.

[0068] Through this invention, causal tensors provide a quantitative measure of the cloud's sensitivity to node intervention, preserving fine-grained behavioral differences after aggregation. Multi-scale graph wavelets combined with NODE time series embedding provide stable temporal features, reducing the perturbations of high-frequency noise on the model. Binary high-dimensional vectors can be safely aggregated and provide a natural binary prior for the subsequent quantum annealing construction of the Ising energy matrix.

[0069] In the joint scenario of three e-commerce companies and one streaming media merchant, D h The proposed approach uses a set of 10,000, a dz of 512, three wavelet kernel sizes, and a NODE integration interval of 0.1. Experimental comparisons with a baseline model that does not utilize causal tensors and wavelet features show that the proposed approach improves click prediction AUC by approximately 2% and purchase conversion F1 by approximately 3%. Furthermore, the high-dimensional vector aggregation reduces network bandwidth usage by nearly an order of magnitude compared to the original gradient. These results demonstrate the effectiveness of the proposed approach in balancing privacy and performance in cross-merchant scenarios.

[0070] Preferably, the uploaded gradient slices are smoothed using a weighted moving average method to obtain the aggregated gradient data.

[0071] The weighted moving average smoothing process of uploaded gradient slices in this invention performs the triple functions of alignment, denoising, and tuning. Its core concept is to accumulate each merchant's gradient subvectors in time slices, using weighted moving average to eliminate artifacts caused by sudden jitter and asynchronous uploads, while maintaining consistent sensitivity across merchant contributions during aggregation. The following section details the principle, implementation, effects, and examples.

[0072] The cloud collects the most recently arrived gradient slices within a fixed time interval Δt The superscript t represents the current time slice, and M represents the number of merchants who have successfully uploaded slices in this time slice. Simple arithmetic averaging cannot resist the following two types of noise: ① Jitter in the merchant upload link causes transient abnormal amplification or attenuation of the gradient amplitude; ② Short-term offsets in user distribution within batch samples introduce gradient polarization. To overcome this problem, the present invention introduces first-order exponential smoothing in the time dimension and uses confidence weights in the merchant dimension to achieve adaptive tuning, which can be uniformly expressed as:

[0073]

[0074] in Represents the current aggregated gradient vector; Represents the aggregate gradient of the previous time slice; λ represents the smoothing coefficient, which ranges from [0,1]. The larger the value, the stronger the historical inertia is retained. Represents the gradient vector uploaded by the i-th merchant; Indicates the confidence weight of the i-th merchant in this time slice, satisfying The confidence weight measures the credibility of the uploaded gradient, and its design considers three factors: upload completeness rate Batch sample size Gradient amplitude stability The formula is as follows:

[0075]

[0076] in Indicates whether the uploaded slices in this time slice are complete in order (complete is marked as 1, otherwise it decays linearly according to the slice loss rate); Indicates the normalized value of the number of valid samples corresponding to the gradient of this time slice; It represents the stability of the gradient amplitude and is defined as the inverse of the gradient variance over the past K time slices.

[0077] As can be seen from the above, the smoothing result combines time inertia and merchant credibility, ensuring that neither excessive historical memory nor excessive amplification of single anomalies is achieved.

[0078] In actual applications, the cloud maintains a circular buffer to store the aggregated gradients of the last two frames and When a new time slice arrives, the buffer contents are read first, and then the following process is executed:

[0079] 1. Slice verification and decoding: Perform hash verification on the gradient slice uploaded by each merchant. After the verification passes, the sub-vector is reassembled into 2. Indicator calculation: update in Calculate within the sliding window K, where K is an integer between 10 and 20. 3. Weight normalization: Calculate 4. Smooth aggregation: calculation produces And write the buffer to overwrite the oldest frame. 5. Abnormal clamping: If If the value exceeds two standard deviations from the historical mean, it is scaled proportionally to avoid transmission explosion.

[0080] Through the present invention, exponential smoothing has a natural low-pass filtering effect on single high-amplitude fluctuations, and the influence of outliers on the aggregate gradient is controlled within the range of (1-λ). Achieve dynamic allocation based on data quality without manually setting thresholds; when a merchant has upload jitter, its weight will automatically decrease. Evaluation can prevent small sample merchants from experiencing excessive gradient variance, which can lead to unstable updates. Weights are derived from computable metrics, and subsequent model diagnostics can track merchant-level contributions.

[0081] In the Double 11 promotion peak experiment, two types of merchants were collected: clothing (short-term high click peak) and virtual ticket (payment instant concentration). In the experiment, λ was set to 0.6 and K was set to 15. The upload packet loss rate of clothing merchants increased to 0.12 due to high concurrency; the packet loss rate of ticket merchants remained at 0.01. (t) Automatically reduce the weight of clothing merchants by about 18%, so that the final The L2 norm of the smoothed solution was reduced by 22% compared to the unsmoothed solution, successfully avoiding gradient explosion. After the two-hour peak, the system recovered to a stable gradient trajectory within five minutes, demonstrating the resilience of this smoothing strategy to extreme traffic shocks.

[0082] Preferably, the relationship graph is a hypergraph comprising user nodes, session nodes, product nodes and context nodes, and the edge weights of the hypergraph are determined by the time difference of the interaction events and the event type coding.

[0083] During the cloud-based joint modeling phase, to simultaneously capture the short-term context of user-product interactions, long-term historical preferences, and the modulating effect of promotional context on decision-making, this paper abstracts multi-source behavior streams into a four-element heterogeneous hypergraph. This hypergraph consists of a node set consisting of user nodes, session nodes, product nodes, and context nodes, and an edge set consisting of interaction hyperedges covering these four types of nodes. Hyperedge weights are determined by combining the time difference between interaction events and event type codes. This design balances high-order interaction completeness with trainability, providing a unified topology for subsequent causal inference and graph-domain convolution.

[0084] Node design: User nodes correspond to unique user IDs and aggregate their long-term interest vectors; Session nodes describe short-term intentions within the same login cycle; Product nodes carry multi-dimensional attribute embedding (category, brand, price range); Context nodes represent external factors such as promotion rhythm and inventory status. These four types of nodes together constitute a node set. The subscripts u, s, g, and c correspond to users, sessions, products, and contexts, respectively.

[0085] Hyperedge construction: A real user-product interaction often depends on both the login session and the marketing context, so a simple bipartite graph cannot describe this type of four-element association. This invention creates a hyperedge for each original behavior record. The hyperedge contains at least one user node A session node A product node and a context node The set of four-element nodes participates in subsequent weight calculation and propagation. This definition of a hyperedge can express high-level facts such as "user U clicked or paid for product G in promotional context C in session S," naturally preserving causal clues.

[0086] Edge weights are defined to measure the impact of a hyperedge on the global model loss, introducing a time decay factor and event type sensitivity. Let Δt be the interval between the time of an interaction event and the previous event of the same type, and e be the one-hot vector of the event type. The edge weight function is written as:

[0087]

[0088] Where γ is the time decay coefficient, and W is the type similarity matrix, which is updated during model training. The first term ensures that the latest interactions are given higher weights; the second term uses a learned matrix to characterize the different contributions of clicks, browsing, and payments to the target task.

[0089] In implementation, the time difference Δt is obtained by subtracting the behavior log timestamp; the event type code is directly mapped by looking up the enumeration table to avoid the performance loss caused by dynamic string comparison.

[0090] Causal tensor generation,After the hypergraph is built, the present invention adopts the node stem prediction strategy to generate the causal representation tensor C. Replace its key attributes with control values, measure the global loss increment Δl(v) through a forward-backward propagation, and write the increment to the main diagonal of the tensor:

[0091] C v,v =Δl(v)

[0092] The size of the tensor is consistent with the number of nodes, and the elements that do not participate in the intervention are set to zero. Due to the time and event type information introduced in the edge weight, the tensor can be directly used as the self-loop weight in the graph convolution, thereby enhancing the significance of high-weight nodes in representation learning. In practice, in order to reduce computational costs, random intervention sampling is only performed on nodes with high PageRank values. The sampling ratio is given in the embodiment of the specification. The multi-scale features of the graph domain are based on the spectral wavelet kernel of the normalized Laplace matrix L:

[0093] Ψ m =L m / 2 exp(-αL)

[0094] The multi-scale convolution results are obtained by applying the node features at three non-adjacent scales m. The convolution results are concatenated along the feature dimension to form a multi-scale feature tensor H. ms The Laplace L is calculated by reducing the hyperedge to a weighted adjacency matrix and then normalized symmetrically. The time series embedding multi-scale feature sequence is fed into the recurrent neural network to obtain the instantaneous hidden state s t . t As initial values, solve the neural ordinary differential equation:

[0095]

[0096] Get the time embedding z final . Vector z final Smoothing captures the dynamic evolution of nodes in the continuous time domain, which helps downstream generative models make more stable predictions of future sequences.

[0097] Random projection and binarization, z finalMultiply it by the pre-generated Rademacher binary matrix P, quantize it by tanh and sign functions to obtain a high-dimensional pulse vector h, and store it bit by bit as a Boolean array.

[0098] Since high-dimensional pulse vectors are all composed of ±1, lossless aggregation can be achieved by performing bitwise addition on similar vectors uploaded by different merchants, and the aggregation results are not easy to infer the privacy information of a single merchant.

[0099] Through the present invention, the hypergraph quaternary structure retains high-order interactions, enabling the model to simultaneously perceive three signal paths: user-product pairing, short-term conversation preferences, and promotional contexts. Time decay + event encoding weights allow the model to automatically learn the importance of different behaviors in different time periods, and performs particularly well in flash sales and flash promotion scenarios. The causal tensor provides node-level significance screening, improving the over-smoothing problem of graph convolution on long-tail nodes. The combination of multi-scale wavelet kernels and NODE provides a smooth representation across scales and time domains, significantly reducing gradient noise. Binary high-dimensional vectors can naturally interface with the Ising model in quantum annealing, enabling seamless integration of subsequent decision modules.

[0100] In an embodiment, a hypergraph including two million user nodes, fifty million session nodes, three hundred thousand product nodes and seventy situation nodes is constructed in a joint environment of four merchants. The time decay coefficient γ is set to a constant that matches the half-life of the behavior, and eight event types are enumerated. The intervention sampling is run for thirty minutes, and the number of intervention nodes per minute is controlled at one thousandth of the total number of nodes. Online experimental data shows that compared with the version without causal tensor, the click-through rate of products is increased by two percentage points; when fixed weights are used instead of learning matrices, the click-through rate is only increased by 1.2 percentage points, indicating that the present invention can more effectively distinguish the impact of behavior types on model output after introducing learning edge weights. In the weighted aggregation stage, the length of the pulse vectors uploaded by the four merchants is consistent with 10,000. The single aggregation calculation takes less than 0.5 milliseconds, and the network bandwidth consumption is one order of magnitude lower than the original gradient vector.

[0101] Preferably, the causal representation tensor is generated by performing an intervention operation on the node attributes of the hypergraph, calculating the numerical difference before and after the intervention and writing it into the diagonal of the tensor.

[0102] The core idea behind generating causal representation tensors is to quantify each node's marginal impact on the global prediction output through controllable manipulation of node attributes within a unified loss function framework. Unlike traditional approaches that measure node importance using adjacency weights or degrees, this method embeds "pseudo-experiments" directly within the neural network's forward-backward propagation chain. This approach uses gradient differences to evaluate the consequences of node attribute changes and writes these differences into the tensor's diagonal, achieving traceable, trainable causal weights that are tightly coupled to the task objective.

[0103] Hypergraph node attributes are defined as follows: user nodes record long-term preference vectors, product nodes record multidimensional attribute embeddings, session nodes record short-term click trajectory summaries, and context nodes record promotion and inventory signals. To facilitate intervention, the present invention predefines a set of controllable attributes for each node type. For example, controllable attributes for product nodes include price range, brand identity, and inventory level; controllable attributes for context nodes include promotional discount rate and channel exposure level. This set is listed in a table in the Examples section of the specification.

[0104] Intervention operation principle, let the complete input feature tensor be X, and the model forward predicts the output The corresponding loss function is Perform intervention on a controllable attribute of node v, that is, "force the attribute to be replaced with the reference value", and input X after intervention \v The present invention uses the same forward-backward process to recalculate the loss The difference between the two:

[0105]

[0106] Reflects the marginal contribution of node v attribute to the current task: if Δl v >0, indicating that replacing the attribute increases the loss, and keeping the original value of the node has a positive effect on the prediction; on the contrary, Δl v <0 means that the node attribute has a negative impact on the result.

[0107] The following strategy is used for reference values: numerical attributes are approximated by their median quantiles within the historical distribution of the same merchant; categorical attributes are evaluated by the most frequently occurring mode; and continuous feature sequences are averaged using a sliding window. This ensures that interventions only remove information about the node itself while preserving the overall distribution, consistent with the principle of counterfactual analysis: "change one factor while keeping the others constant."

[0108] Tensor writing logic, let the total number of nodes be N, causal representation tensor Initialized to zero matrix. Each time a node intervention is performed, Δl v Write the main diagonal: Non-diagonal elements are kept zero to reduce storage overhead and highlight single-node effects. If pairwise interventions need to be evaluated, a second-order tensor can be defined in the extended version of the dependent claims; the main version of the present invention focuses on the importance of single nodes, so only the diagonal elements are written.

[0109] Algorithm flow: Node screening, using PageRank to select the top R nodes in the hypergraph to enter the intervention pool, to avoid repeated calculation of long-tail nodes. Attribute replacement, traversing the controllable attributes of the nodes in the pool, replacing the original values ​​with reference value combinations to generate intervention inputs. Loss assessment, a forward reasoning is obtained Update with the original loss difference To prevent the scale drift between different batches, tensor normalization is performed. Non-zero elements in the CNN are z-scored. Cache update: Intervention results are exponentially averaged within a sliding window between batches to keep the tensor sensitive to new information without excessive oscillation.

[0110] Integrated into graph convolution, the causal diagonal elements are regarded as self-loop weights in the subsequent graph convolution network. The convolution formula is:

[0111]

[0112] in is the reduced-order adjacency matrix of the hypergraph, is the degree matrix, H (l) is the node representation of the lth layer, w (l) is a learnable parameter, and σ(·) is an activation function. Finally, the self-loop weights are adaptively amplified or weakened according to the node causal effects, thereby alleviating oversmoothing and enhancing interpretability.

[0113] This method derives causal information directly from loss changes, which is more aligned with task objectives than simple metrics. When node features are missing or abnormal, C-weighting can automatically suppress the effects of noise nodes on the convolutional output. Subsequent decision layers can trace back to high-weight nodes and output "recommendation explanations" such as "due to the user's high proportion of purchases in popular sessions for similar products." Intervention differences are first normalized based on gradients and then averaged over windows to reduce bias due to sample size differences.

[0114] In this example, on a real dataset containing three million nodes, the intervention pool size was set to 10,000. Compared to a baseline GCN without a causal tensor, the proposed method achieved a 1.9% improvement in click-through rate (AUC) and a 4.2% increase in long-tail product exposure with the same number of convolutional layers. Furthermore, randomly replacing the intervention nodes with the same number of low-PageRank nodes did not significantly improve model performance, validating the efficient and computationally efficient screening strategy.

[0115] For the recommendation explanation experiment, we randomly sampled 100 recommendation examples and recorded the node types that led to the highest recommendation weights. User nodes accounted for 48%, product nodes for 32%, context nodes for 15%, and conversation nodes for 5%. Human evaluation determined that 87% of the explanations were understandable to business operations personnel, demonstrating a high degree of consistency between the causal tensor and business semantics.

[0116] Preferably, in the relationship graph, a bipartite subgraph consisting of user nodes and product nodes is first extracted; multi-order power operations are performed on the normalized Laplace matrix of the bipartite subgraph, and the convolution coefficients of each order are calculated in combination with the exponential decay kernel; the convolution coefficients of different orders are spliced ​​in sequence to obtain multi-scale features of the graph domain.

[0117] In the cloud-based relational hypergraph, the user node-product node bipartite subgraph condenses the core collaborative signal of the cross-merchant recommendation system: one end is a set of users with long-term preferences, and the other end is a set of products with multi-dimensional attributes; the edge between the two reflects the actual interaction intensity. If the original adjacency information is used directly, the model after convolution tends to favor highly popular products and ignore fine-grained structures. The present invention implements a "local-global" signal decomposition in the Laplace spectral domain through a spectral multi-scale method, and then splices the multi-order convolution results to obtain multi-scale features in the graph domain, which not only retains microscopic sparse associations but also takes into account the macroscopic topological backbone.

[0118] The normalized Laplace matrix is ​​constructed and the bipartite subgraph is denoted as in is a collection of user nodes, is a set of commodity nodes. Select the weighted adjacency matrix A of this subgraph, element A ij For user u i With product g j The interaction frequency is the logarithmically smoothed value. Calculate the degree matrix D = diag (d1, ..., d n ), where d i =∑ j A ij The normalized Laplacian matrix is ​​defined as:

[0119] L=ID -1 / 2 AD -1 / 2

[0120] I is the identity matrix. Normalization ensures that data uploaded by different merchants can still obtain comparable features in the spectral domain even when the edge density varies greatly.

[0121] Multi-order exponentiation, a direct convolution on L can only capture one-hop neighborhood information, while the indirect interest patterns commonly seen in recommendation scenarios need to cross multi-hop paths to appear. To this end, the present invention performs odd-order exponentiation on L:

[0122] L m / 2 ,m∈{1,3,5}

[0123] Three different diffusion ranges are approximated: m = 1 corresponds to a one-hop neighborhood, m = 3 approximates a three-hop influence, and m = 5 reflects a sparser long-chain collaboration. Using odd orders instead of continuous orders can avoid excessive overlap of neighbor information and cause redundancy.

[0124] Exponential decay kernel, the power operation will quickly amplify the spectral components of small degree nodes, introducing an exponential decay kernel:

[0125] exp(-αL

[0126] where alpha is a positive real number to suppress high-frequency noise and improve numerical stability. When the eigenvalue of L is large, exp(-alpha L) decays rapidly, and the corresponding high oscillation component is weakened. The low-frequency structure near the small eigenvalue is preserved, which is particularly beneficial to long-range collaborative patterns. In practice, alpha is set to a constant of the same order of magnitude as the average edge weight reciprocal, which can be determined by grid search.

[0127] Convolution coefficient generation, assuming that the node input feature is h, multiplying the spectral graph kernel by the multi-order power to obtain the convolution kernel:

[0128] Ψ m = L m / 2 exp(-alpha L)

[0129] Then perform convolution h m = Psi m h. The three scale results are sequentially spliced:

[0130] h ms = [h1||h3||h5]

[0131] Form a multi-scale feature of the graph domain. This splicing retains information under different diffusion norms; in the subsequent recursive network, the contributions of the three scale branches are automatically balanced through learnable weights.

[0132] Computational optimization. Directly taking the power of L requires eigenvalue decomposition, and the computational complexity grows quadratically with the number of nodes. The present application uses Chebyshev polynomial approximation to expand L m / 2 into a K-order polynomial, which, together with sparse matrix multiplication, reduces the complexity to Experiments show that when K=5, the error is less than 1% for a million-node graph, and the convolution can be completed within three seconds on a single GPU with 16GB of video memory.

[0133] Through the present application, when m=1, the model is excessively biased towards popular goods; when m=5, short-term session preferences are lost. Multi-scale splicing simultaneously improves the click-through rate of popular goods and the exposure rate of long-tail goods in A / B testing. After adding the exponential decay kernel, the AUC decreases by less than 0.3% under the perturbation of randomly deleting 10% of the edges, while the non-decay version decreases by more than 1.2%. The combination of normalized Laplacian and exponential kernel makes the graph domain features of different merchants have zero mean and unit variance after batch normalization, making joint training more easily convergent.

[0134] Embodiment, construct a two-part subgraph on the mixed data of three clothing merchants and one mother and baby merchant, totaling four million nodes and twenty million edges. Set alpha to 0.5 and use Chebyshev order K=6. Train a three-layer graph convolution and recursive network for ten rounds until it converges. Offline evaluation shows that the multi-scale feature scheme of the present application is 2.5% higher than the single-scale baseline in the F1 indicator of purchase conversion prediction. After being online for fourteen days, the average single price increases by 1.3%, and the proportion of long-tail product exposure increases by 5%.

[0135] In a simulated cold-start experiment, new product nodes were randomly injected and only a small number of initial clicks were retained. The experiment found that using an m=5 convolutional branch to capture long-chain associations increased the cold-start click-through rate of new products by two times compared to not using this branch, demonstrating the importance of high-order diffusion in compensating for sparse interactions.

[0136] Preferably, the time series embedding model is composed of a recursive neural network and a neural ordinary differential equation connected in series, wherein the output of the recursive neural network serves as the initial value of the neural ordinary differential equation.

[0137] Recursive neural networks fold the state of sequences in discrete time, which can effectively extract short-term patterns, but their hidden states use linear interpolation between adjacent moments, which implies a "fixed step size" assumption. When multiple merchants upload batches with unequal time intervals and significant differences in behavior density, this assumption causes the embedding trajectory to be a stepped broken line, making it difficult to maintain numerical smoothness in the subsequent continuous time inference and diffusion reverse process. The present invention connects the recursive neural network (hereinafter referred to as RNN) and the neural ordinary differential equation (hereinafter referred to as NODE) ​​in series, so that the RNN is responsible for the local folding of discrete events, and the NODE is responsible for the physically consistent fluid evolution of the hidden state in the continuous time domain, thereby realizing the discrete-continuous dual-domain information fusion.

[0138] The RNN part uses the gated recurrent unit. Given a multi-scale feature sequence in the graph domain (The time sequence is obtained from the user behavior record), RNN calculates the recursive update:

[0139]

[0140] in is the hidden state of the tth step, and d is the hidden dimension. After T steps, the final discrete representation s is obtained T In order to reproduce the smooth evolution of node embedding on the non-uniform time axis, the NODE segment will be s T As initial conditions for ordinary differential equations:

[0141] z(0)=s T

[0142] Then solve in the continuous interval [0,τ]:

[0143]

[0144] z(t) represents the continuous-time embedding at time t, f(·) is a learnable vector field, φ is its parameter set, and τ is the endpoint of the integration. The vector field is implemented using a two-layer fully connected network with SiLU activation, so that the function family satisfies the Lipschitz condition, guaranteeing the existence and uniqueness of the solution. The integral z(τ) is computed using a Dormand–Prince solver with an adaptive step size.

[0145] The working mechanism of this combined structure can be understood as follows: the RNN is responsible for dimensionality reduction and folding discrete, unequal-length, noisy, high-dimensional input sequences, eliminating length differences between batches. Based on this, the NODE establishes a continuous dynamics of hidden states flowing over "virtual time" to fill the gaps between discrete samplings, making the final embedding continuous in the sense of derivatives. Because the parameters of the vector field f are learnable, the model can automatically adjust the evolution speed based on the rhythm of real-world behavior: if the user does not interact for a long time, the ODE solution automatically tends to be stable within the interval; if the user interacts with a high frequency for a short period of time, the ODE solution exhibits rapid changes without numerical oscillations.

[0146] To maintain stable gradient propagation, this paper uses the adjoint sensitivity method for memory optimization during the end-to-end backpropagation of ODE segments, avoiding the storage of intermediate states during the solution process over long sequences. Combined with mixed-precision solving, the overall time series embedding module can process approximately 30,000 embedding requests per second on a single A100 GPU, meeting the concurrency needs of large merchants.

[0147] In terms of technical performance, compared with the baseline using only RNN, NODERNN tandem has achieved improvements in the following indicators: in the non-uniformly sampled test set, the continuous-time interpolation error (reconstructing hidden trajectories using linear regression) is reduced by 37%; in the click sequence prediction task, the AUC is improved by 1.6%, mainly reflected in the long-term window user segment; in the gradient reverse process of the subsequent diffusion generation module, the gradient norm distribution is more concentrated, and the training convergence steps are shortened by an average of 12%.

[0148] In this embodiment, a fresh food merchant (users browse the merchant in fragments multiple times throughout the day) and a virtual ticketing merchant (users visit the merchant in bursts during the ticketing period) were selected for comparison. Using the same graph feature input, the RNN-NODE cascade and pure RNN were trained on the two merchant data respectively. In the fresh food scenario, the output of the cascade model for the "silent period" from midnight to early morning tends to be constant, while the RNN output shows a sawtooth wave; in the ticketing scenario, the absolute value of the derivative output by the cascade model during peak hours is significantly higher than that during quiet periods, which is more consistent with the real behavior rhythm. Experiments show that the ODE vector field can adaptively adjust the evolution speed according to the hidden state.

[0149] Interpretable analysis: Projecting the vector field f onto the principal component plane reveals a damped attenuation of the user's historical preferences (the first principal component) and an impulsive excitation of the short-term interest in the session (the second principal component). This is consistent with business experience: during long periods of inactivity, the system should reduce historical weights; during short-term frequent interactions, the session weights should be rapidly increased.

[0150] Through the serial design of RNN-NODE, the present invention achieves a seamless transition from discrete sequences to continuous manifolds, providing a differentiable and smooth time embedding representation for the subsequent diffusion reverse process, ultimately bringing dual benefits of accuracy and convergence speed in multi-merchant joint recommendation tasks.

[0151] Preferably, the high-dimensional pulse vector is obtained by multiplying the time embedding representation with a random projection matrix, performing a binarization mapping through a hyperbolic tangent function and taking a sign function, and the resulting binary vector constitutes the high-dimensional pulse vector.

[0152] The generation of high-dimensional pulse vectors aims to provide a shared representation for multi-merchant joint learning that is homomorphically aggregated, difficult to reverse engineer, and numerically concise. This method employs a three-step process of "random projection + hyperbolic tangent nonlinearity + symbolic quantization" to map the continuous-time embedding representation onto a binary high-dimensional hypersphere. This design ensures information density while imparting near-orthogonality to the vectors, making subsequent summation operations between merchants equivalent to hash counting. This approach conserves communication bandwidth and reduces the risk of privacy leaks.

[0153] Temporal Embedding Representation It comes from the RNN-NODE series module in the previous section, whose dimension d z Generally, it is between hundreds and thousands. To enhance the separation between vectors, we first construct a set of random projection matrices Matrix elements are independently sampled according to the Rademacher distribution; since the values ​​are only positive or negative, the matrix can be compressed and stored as a bitmap, and "addition and subtraction" operations without multiplication can be implemented under SIMD instructions. Random projection follows the Johnson-Lindenstrauss lemma, which can approximately maintain the Euclidean distance as the dimension increases, that is:

[0154]

[0155] Here P row Represents a row of the matrix, for qualitative purposes only. This invention does not require a specific mathematical proof of the upper bound of distortion, but rather verifies the equivalent preservation through experiments later in this paper. Multiplying z by P yields the intermediate representation r = Pz. Since the distribution of r follows the central limit theorem and is approximately Gaussian, direct quantization can result in uncontrollable jitter for a large number of elements near zero. For this purpose, hyperbolic tangent compression is introduced:

[0156] u=tanh(r)

[0157] in The input is compressed to (-1, 1) numerically, and a larger gradient is provided for elements close to zero, making it easier to backpropagate in the subsequent training phase. The sign function is then used for hard threshold quantization:

[0158]

[0159] Get the final high-dimensional pulse vector A two-stage nonlinearity of tanh followed by sign is chosen here. On the one hand, it is convenient to use the straight-through estimator (STE) to approximate the gradient of sign to be constant 1, maintaining differentiability during end-to-end training; on the other hand, compared with directly taking the sign of r, tanh can reduce the impact of extremely large values ​​after random projection and avoid imbalance in the same row after quantization.

[0160] After the binarization is completed, each merchant holds a vector of the same size, distribution, and approximately orthogonal. If the merchant set is recorded as {1,…,N}, the cloud can directly perform bitwise summation:

[0161]

[0162] Obtain a high-dimensional vector H across merchants. Since the vector elements are only ±1, the summation result falls within the integer range and does not require floating-point storage; and for any two merchants p and q, the vectors are:

[0163]

[0164] This means that different merchants are in a nearly orthogonal relationship in high-dimensional space, and their respective contributions are independent of each other after homomorphic summation. This not only suppresses the excessive dominance of "merchants with large traffic" in model updates, but also prevents the characteristics of a single merchant from being easily restored.

[0165] In terms of performance, high-dimensional pulse vectors bring three advantages. First, communication compression: a single 32-bit floating-point vector is converted into a single-bit binary vector, reducing bandwidth requirements by a factor of thirty-two. Second, improved security: the quantized vector satisfies the binary distribution homomorphism property, rather than being reversible. In addition, the random projection matrix is ​​randomly generated and encrypted when the system starts, making it difficult for an attacker to recover z even if h is intercepted. Third, it is friendly to downstream quantum annealing: the Ising energy model itself uses {-1,1} spin variables, and high-dimensional pulse vectors can be directly mapped to the spin state initialization of the quantum annealing processor without the need for secondary quantization.

[0166] Example D h =10,000, d z=512 configuration as an example, performance was compared in a joint training environment with four merchants. The uncompressed solution uploaded approximately 20MB of gradients per batch, while the high-dimensional pulse solution only 0.625MB per batch, reducing bandwidth usage by 97%. The model accuracy (AUC) decreased by less than 0.4% compared to the floating-point vector solution, far below the acceptable threshold for business use. During the security assessment, a known-plaintext attack was used to perform random projection inversion on the intercepted h. The recovery error (MSE) exceeded 0.45, indicating that it was unable to effectively leak sensitive user behavior.

[0167] In summary, the high-dimensional pulse vector constructed by random projection, hyperbolic tangent compression and symbolic quantization not only meets the homomorphic additivity and compressive transmission required for cross-merchant joint learning, but also provides unique advantages in information security and quantum annealing compatibility, laying a unified binary representation foundation for the subsequent diffusion generation and enhanced decision-making of the present invention.

[0168] A generative reverse process is performed on the cross-merchant high-dimensional vector according to a preset noise strategy to obtain a prediction vector. The prediction vector and the time embedding representation are mapped into an energy matrix. The action vector is obtained through quantum optimization sampling. The action vector and the cross-merchant high-dimensional vector are then input into the reinforcement learning network to output the recommendation decision data.

[0169] The cross-merchant high-dimensional pulse vectors are approximately orthogonal on the binary hypersphere and can be used as a global state representation of a unified behavioral scenario. Based on this representation, the present invention constructs a three-level coupled decision chain of "generative reverse process-quantum optimization-reinforcement learning": first, a generative reverse process with noise scheduling is used to predict the user-product interaction distribution in the next thirty minutes; second, the prediction results and time embedding are jointly mapped into an Ising energy matrix, and the action vector is obtained through quantum annealing sampling; finally, the action vector and the cross-merchant high-dimensional vector are jointly input into the reinforcement learning network to output the recommended decision data. The three-level chain ensures the "pre-judgment-global sampling-local fine-tuning" logical closed loop, which can not only jump out of local extreme values, but also self-calibrate with real-time feedback. The following is a detailed description in four parts.

[0170] Generative reverse process, cross-merchant high-dimensional impulse vector is recorded as Among them D h is the pulse dimension, and N is the number of participating merchants. According to the variance of H Select the noise table {β1,…,β T}, noise scheduling function:

[0171]

[0172] β min ,β max is a constant, is the historical maximum variance. Forward perturbation process:

[0173]

[0174] The binary input is gradually diffused into Gaussian noise. Inverse denoising network ∈ θ Predict noise and use random replication techniques to inject topological chaos Monte Carlo annealing every L steps. The energy function L 小波 For the multi-scale wavelet Laplace in the previous section, complete the reverse process and output the predicted pulse vector The value range of each dimension [-1, 1] represents the continuous representation of the future window click probability density after tanh compression.

[0175] Time embedding is mapped to energy matrix, time embedding From the RNN-NODE module. Using bilinear mapping:

[0176]

[0177] Among them J ij is the Ising coupling coefficient, h i is the local field, e j is the jth basis vector, W J ,w h is the weight matrix and vector obtained from training. Construct the energy function:

[0178]

[0179] s∈{-1,1} K is the quantum annealing spin variable, K is equal to the number of candidates to be recommended. The quantum optimization sampling energy matrix is ​​embedded and mapped to the quantum annealing processor through Chimera, and the annealing time is set to a constant. The low energy state set {s (1) ,…,s (Q)}. Select the lowest energy s * As the action vector, Indicates that candidate product i enters the prior recommendation pool. Sampling distribution Pr QA (s) are output simultaneously, injecting entropy incentives for subsequent reinforcement learning exploration-exploitation balance.

[0180] Reinforcement learning fine-tuning, cross-merchant high-dimensional pulse vector H, quantum action vector s * Concatenated with the time embedding z into the environment state s RL . Use deep Q network to approximate the action value function:

[0181]

[0182] Where a is the specific recommended location and candidate mapping action, u and V are learnable parameters, and η is the entropy regularization weight. Execute the ε-greedy strategy to select the final recommendation list and real-time inventory adjustment actions, forming the recommendation decision data and pushing it to each merchant front end. The user click and purchase behavior return to form a reward r, and the next state s RL 'composition (s RL ,a,r,s RL ′) Store the experience replay and periodically update the Q network.

[0183] Through the present invention, the generative reverse process outputs Future interactions are multi-modal distributed, avoiding predicting only average behavior; quantum annealing is based on the Ising energy's instantaneous traversal of exponential-scale space, which can jump out of local extreme values ​​and make up for the lack of exploration in the early stage of reinforcement learning; the deep Q network uses quantum sampling as a priori, fine-tunes weights under real-time feedback, and quickly adapts to dynamic constraints such as inventory and price; the sampling probability enters the Q network entropy incentive, and the Q network reward is back-written by the gradient to affect the next batch of noise scheduling, forming a three-layer coupled closed loop.

[0184] In this example, two fast-moving consumer goods merchants and one furniture and musical instrument merchant were selected, with a total candidate set of 12,000 SKUs. The quantum annealing processor was set to 20 microseconds for annealing, with a single batch sampling of 128 groups. A control group used a pure DQN without quantum priors. This method improved click-through rates by 2.7% at the user-SKU level and purchase conversion rates by 1.4%, while also shortening the convergence rate from 30,000 batches to 27,000. In emergency testing of a sudden inventory surge scenario (flash sales), this method reduced the average out-of-stock penalty by 30%.

[0185] Description, where is the predicted pulse i-th dimension, z is the time embedding vector, W J 、w h is the mapping weight; s i is the spin value; u and V are the Q network weights; η is the entropy adjustment coefficient; Pr QA (a) is the probability of quantum sampling for action a. All symbols appear only here to ensure unambiguity.

[0186] Through a three-layer coupling chain, the present invention realizes a dynamic decision-making mechanism of "prediction-optimization-scheduling", which has excellent adaptability and universal promotion value to behavior surges and inventory fluctuations in multi-merchant scenarios.

[0187] Preferably, the generative reverse process determines a noise scheduling table according to the variance information of the cross-merchant high-dimensional vector, and periodically introduces topological chaos Monte Carlo annealing in the reverse iterative process.

[0188] The generative reverse process undertakes the multimodal prediction task of the user-product interaction distribution in the future time window. Unlike the traditional fixed noise diffusion model, the present invention dynamically adjusts the forward noise table according to the variance of the high-dimensional pulse vector across merchants, so that the denoising network obtains sufficient exploration space in high-uncertainty scenarios and maintains convergence stability in deterministic scenarios; at the same time, topological chaos Monte Carlo annealing (TCM annealing) is periodically inserted into the reverse iterative chain to enhance the capture of long-tail abnormal patterns and reduce the risk of pattern collapse. The following is an explanation from four aspects: the noise scheduling principle, the TCM annealing mechanism, the coupled implementation process and the effect of the two.

[0189] Noise scheduling principle, cross-merchant high-dimensional pulse vector It is obtained by summing the pulse vectors of each merchant bit by bit. Define variance:

[0190]

[0191] The value reflects the balance of merchant contributions and the uncertainty of user behavior: if the traffic of some merchants increases dramatically or business events occur, will increase significantly; on the contrary, when user behavior is stable or the contributions of merchants are similar, its value is small. Use this statistic to construct a linear noise scheduling table:

[0192]

[0193] where β min ,β max is a system constant, = maximum historical variance. This allows for greater noise distribution during periods of high variance, allowing the generative model to explore more potential future trajectories. During periods of low variance, the convergence step is shortened, improving denoising accuracy. Once generated, the schedule is fixed throughout the entire forward diffusion and reverse denoising process.

[0194] TCM annealing mechanism, reverse denoising network of diffusion model ∈ θ It is easy to fall into a single peak output on extremely sparse click sequences. The present invention inserts a TCM annealing every L steps in the reverse iterative chain:

[0195] 1. Calculate the current sample x k The topological energy of:

[0196]

[0197] Among them L 小波 is the wavelet Laplace matrix obtained in the previous section. This energy is sensitive to high-frequency topological oscillations and can highlight long-chain cooperative modes;

[0198] 2. Perform Metropolis updates in accept-reject format:

[0199]

[0200] Probability of acceptance:

[0201] p acc =min(1,exp[-(E(x′)-E(x k )) / T])

[0202] Where T is the annealing temperature;

[0203] If the update is accepted, set x k ←x′ and continue with conventional denoising; after one round, the temperature decreases according to T←ηT (η<1). TCM annealing is equivalent to periodically injecting chaotic perturbations into the energy landscape, allowing the sampling chain to transition to the far tail of the distribution and alleviate mode collapse.

[0204] The coupling implementation process includes: Generate noise table {β t}, perform forward diffusion; reverse iterate t = T → 1 denoising; perform a TCM annealing when t mod L = 0; record the final sample This process is compatible with any denoising network with a UNet or Transformer structure, does not increase network complexity, and only inserts lightweight energy discrimination and Gaussian perturbation operations into the inference chain.

[0205] Through the present invention, the noise level is Dynamic scaling ensures multi-peak generation in high-variance scenarios such as flash sales peaks, and maintains denoising accuracy during daily stable periods. TCM annealing significantly improves the coverage of cold-start products and rare conversation paths through topological energy screening; offline evaluation of sparse click recall rate increases by 14%. Scheduling noise avoids excessive random perturbations, the average denoising iterative loss decreases steeper, and the number of training rounds is reduced by approximately 11%. All operations are based on binary pulse vectors, without exposing the original merchant features; the topological matrix L 小波 Calculated by public weights, no privacy involved.

[0206] In this example, the variance of merchants A, B, and C reaches a historical high two hours before the big promotion. The system automatically sets β max Improved to 1.2β baseline TCM annealing is inserted every 40 steps in the denoising chain, with an initial temperature of 1.0 and a decay coefficient of 0.95. After 72 hours of monitoring, the click prediction AUC is improved by 2.1% compared to the fixed noise + no annealing baseline, and the click rate of cold start products is increased by 3.4%. For periods without promotions, Fall back to the baseline of about 60%, automatically reduce the scheduling noise, and keep the model accuracy unchanged.

[0207] Preferably, the quantum optimization sampling is completed on a quantum annealing processor, and the action vector sampled is input into the reinforcement learning network together with the cross-merchant high-dimensional vector, wherein the reward signal of the reinforcement learning network is calculated according to user click feedback and payment feedback.

[0208] The cross-merchant recommendation decision-making stage minimizes Ising energy as an upper search, and then realizes lower fine adjustment by a deep reinforcement learning network. The quantum annealing processor undertakes the global search task: according to the predicted pulse vector generated in the last stage and the time embedding representation z, the coupling matrix J is mapped ij and the local field h i . For specific mapping, see the foregoing, and this paragraph focuses on annealing sampling and reinforcement learning cooperation.

[0209] The quantum annealing processor works near absolute zero, and by controlling the coupling coefficient of the quantum bit, the binary selection variable {s i} of the recommendation candidate set is mapped to the Ising energy function:

[0210]

[0211] After starting annealing, the system slowly evolves from a uniform superposition state to a problem Hamiltonian, and when the annealing time reaches the set value, multiple measurements obtain a spin vector sample set {s (q)}. Spin value +1 indicates that the candidate product enters the prior recommendation pool, and -1 indicates that it is excluded. Due to the quantum tunneling mechanism, it can cross the high-energy barrier that is difficult to overcome in classical simulation, and the sampling result is closer to the global optimum in the case of large-scale coupling.

[0212] In order to make the subsequent decision-making network consider exploration and utilization, the system not only retains the spin vector s * with the lowest energy as the action prior, but also statistics the sample frequency to form a probability distribution Pr QA (s i =+1). This step provides an entropy incentive source for reinforcement learning, avoiding degeneration into a greedy strategy in the reinforcement phase.

[0213] The cross-merchant high-dimensional pulse vector H still carries the comprehensive interest between merchants, and the quantum action vector s * gives the selection bias at the product level. After splicing, the environment state is formed:

[0214] S RL =[H||s * ||z]

[0215] The input is fed into a deep Q-network. The network structure consists of three fully connected layers, with rectified linear units used in the hidden layers. It outputs value estimates for all legal actions. An action is defined as a binary pairing: "insert a given item from the candidate pool into a specified display slot." The action space is compressed using hashing to avoid dimensionality explosion. To incorporate the ensemble prior, entropy regularization is introduced to rewrite the Q-estimate:

[0216]

[0217] Where η is a fixed weight. The network training uses the temporal difference method and the target regression:

[0218]

[0219] The discount factor γ<1 controls the decay of future returns. The reward signal design is strictly centered around click and payment feedback. After exposure, the system records the user's click mark c∈{0,1} and payment mark p∈{0,1}. Define the immediate reward:

[0220] r=αc+βp,α,β>0

[0221] Where α and β are constants, which are configured by the merchant's goals. The separation of click rewards and payment rewards helps to achieve an adaptive balance between low-customer-price, high-click industries and high-customer-price, low-frequency industries. The linkage process is as follows: Quantum annealing completes the sampling and obtains s * With Pr QA (·); splicing H, s * 、z gets the state s RL ; The deep Q network selects action a with the ε-greedy strategy, and ε gradually converges with iteration; the independent strategy execution component generates a recommendation list and inventory scheduling instructions based on the action, and writes them into the dispatch queue; the user behavior returns, the system calculates the reward r, and saves (s RL ,a,r,s′ RL ) to replay the experience; batch sampling and replay are performed every fixed number of steps, and the network parameters are updated by gradient descent; at the same time, the quantum sampling frequency remains unchanged to ensure continuous injection of priori.

[0222] Quantum annealing can search for energy-minimizing solutions in exponentially coupled spaces, ensuring parallel exploration. Deep reinforcement learning networks use feedback signals to rapidly fine-tune responses to local environmental perturbations. Experiments compared two baselines, pure reinforcement learning and pure quantum sampling. The combined approach demonstrated a 2.1% increase in click-through rate, a 1.3% increase in payment conversion rate, and a 28% decrease in out-of-stock penalties over a seven-day A / B test. Convergence rate is signaled by reward stability, and the hybrid approach reached steady-state approximately 3,000 update batches earlier than pure reinforcement learning.

[0223] In a practical example, for a fresh food merchant's flash sale scenario, the system mapped approximately 8,000 candidate SKUs daily to a 2048-qubit subgraph, with a fixed annealing time of 20 microseconds and a single batch sampling of 128 groups. Combined with a bidirectional entropy-driven deep Q-network, the final recommendation list was returned within 50 milliseconds even during periods of rapid inventory fluctuations. Compared to a reinforcement learning version without quantum priors, GMV increased by 4.5% in the first minute of the flash sale, demonstrating that quantum annealing provides global leapfrogging capabilities for extremely short-term decision-making, while reinforcement learning captures fine-grained feedback.

[0224] An updated gradient vector is generated based on user feedback corresponding to the recommended decision data, and the updated gradient vector is sent back to the merchant end to update the local learning model to form a self-calibration closed loop.

[0225] In a multi-merchant federation scenario, relying solely on cloud-side model push strategies without end-side updates can easily lead to "cold feedback" lags - that is, real user interests change rapidly on the merchant front end, while the global gradient on the cloud requires multi-layer aggregation to synchronize, which in turn affects the accuracy of individual recommendations. The present invention sets up a local self-calibration closed loop: the recommendation decision data pushed from the cloud is adopted and executed by each merchant, and the merchant captures real-time user feedback and calculates updated gradients online; the updated gradients are synchronously written into the merchant-side private model before being transmitted back to the cloud, realizing "cloud-end" bidirectional gradient flow. This closed loop takes into account both global coordination and personalized real-time adjustment, and is explained below from five aspects: feedback collection, incremental error modeling, gradient derivation, feedback protocol, and closed-loop convergence.

[0226] Feedback collection and label definition, after the front-end rendering of the recommendation results is completed, each exposure record is accompanied by a unique exposure number. The merchant-side tracking system monitors three types of positive feedback events: clicks, add-to-cart, and payment; and one type of negative feedback event: bounce (no positive behavior is performed within the set time window after exposure). In order to unify the gradient supervision signal, the present invention maps multiple feedbacks to scalar rewards:

[0227] r i =α1·click i +α2·cart i +α3·pay i -α4·bounce i

[0228] where click i ,cart i ,pay i ,bounce i ∈{0,1} is the event trigger mark; α k Preset positive weights for the business side. If multiple positive behaviors occur for the same exposure, they are accumulated in sequence. Discretize the reward into labels y i ∈{0,1}: when r iIf the value is ≥θ, it is considered a positive sample; otherwise, it is considered a negative sample. The threshold θ is determined by the merchant's historical revenue curve or A / B experiment.

[0229] Incremental error modeling, the local model already has parameters θ (t-1) . Collect new batch feedback samples Finally, construct the incremental loss:

[0230]

[0231] Where CE represents binary cross entropy, σ is Sigmoid, f is the local network forward function, θ sync is the snapshot of the last alignment with the cloud, and λ is the trade-off regularization. The second term prevents the client from overfitting and causing serious drift with the federated backbone model. (t-1) Find the gradient:

[0232]

[0233] The gradient is first gradient clipped:

[0234]

[0235] G max To set the threshold. Then normalize and divide the data into fixed-length blocks and encapsulate them into an updated gradient slice package. At the same time, use the learning rate η local Perform a parameter reduction on the client side:

[0236]

[0237] This allows for instant self-calibration. Parameter changes only affect client-side inference and do not affect the cloud-based master model until the next synchronization.

[0238] The backhaul protocol encapsulates updated gradient slices, tagged with a batch number and event window number, and transmits them back to the cloud via the same encrypted channel as the original gradients. To ensure timeliness, the client employs "asynchronous priority upload"—in the event of network congestion, the upload of updated slices can be temporarily suspended without affecting real-time rendering. Upon receipt, the cloud merges the slices with the daily gradient slices into the homomorphic summation queue, achieving incremental merging.

[0239] Closed-loop convergence and effect: The cloud periodically (for example, every K minutes) accumulates the two types of gradients and uniformly updates the global model; and regularly sends the latest θ sync The client then resets the device-side regularization baseline. This two-layer loop forms a two-level closed loop of "local high frequency and global low frequency": local calibration adapts to users' instantaneous interests, while global integration maintains collaboration among merchants.

[0240] The experiment was conducted on three merchants for comparison: cloud-based training only: it took 30 minutes to perceive the change in popularity of flash sales activities; end-side online learning only: it can indeed make rapid adjustments, but due to data sparsity, it leads to overfitting of long-tail users; closed-loop of the present invention: the popularity change is accelerated to converge within three minutes, and the F1 difference with the cloud baseline is less than 0.3 percentage points.

[0241] Terminal performance evaluation shows that local gradient derivatives and a single parameter update take an average of 12 milliseconds, below the 16-millisecond threshold for page rendering and without affecting interactive smoothness. Regarding bandwidth, the updated slices contain only extremely sparse gradient subvectors, with a single batch averaging 5KB, a reduction of over 80% compared to the initial gradient packet.

[0242] By implementing feedback-driven micro-updates and closed-loop feedback on the merchant side, the present invention overcomes the time lag bottleneck of the cloud-based collaborative model and achieves high-frequency interest adaptation. At the same time, due to the regularization term constraints and federation synchronization, the end side will not deviate too much from the global goal, ensuring the long-term stability of the overall system.

[0243] The above are merely embodiments of the present application and are not intended to limit the present application. For those skilled in the art, the present application may have various modifications and variations. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present application should be included within the scope of the claims of the present application.

Claims

1. A multi-merchant user behavior deep learning analysis method, characterized by: The following steps are involved: Collect behavioral data related to each merchant's interaction with users, calculate gradient vectors based on the local learning model, encapsulate the gradient vectors into gradient slices, and upload them to the cloud; Aggregate the gradient slices to obtain aggregated gradient data. Based on the aggregated gradient data, a relationship graph describing user behavior is constructed. A causal representation tensor is generated based on the relationship graph. The causal representation tensor and the multi-scale features of the graph domain are input into the temporal embedding model to obtain a temporal embedding representation. Generate high-dimensional pulse vectors corresponding to each merchant using random projection and binarization mapping, and further aggregate the high-dimensional pulse vectors corresponding to each merchant to form a cross-merchant high-dimensional vector; Perform a generative reverse process on the cross-merchant high-dimensional vector according to the preset noise strategy to obtain the prediction vector; The prediction vector and the time embedding representation are mapped into an energy matrix, and the action vector is obtained through quantum optimization sampling. The action vector and the cross-merchant high-dimensional vector are then input into the reinforcement learning network to output the recommendation decision data. An updated gradient vector is generated based on user feedback corresponding to the recommended decision data, and the updated gradient vector is sent back to the merchant end to update the local learning model to form a self-calibration closed loop.

2. The method according to claim 1, characterized in that The behavioral data includes click sequences, dwell time sequences, payment event sequences, return event sequences, and customer service conversation text sequences; The behavior data is sequentially subjected to normalization processing, discretization processing, and word embedding processing to obtain preprocessed behavior feature data; the preprocessed behavior feature data is input into the local learning model in batches, and the gradient vector is calculated through back propagation of the local learning model.

3. The method according to claim 1, characterized in that The uploaded gradient slices are smoothed using the weighted moving average method, and the smoothed results are accumulated in the same vector dimension to obtain the aggregated gradient data.

4. The method according to claim 1, wherein The relationship graph is a hypergraph including user nodes, session nodes, product nodes and context nodes, and the edge weights of the hypergraph are determined by the time difference of interaction events and event type codes.

5. The method according to claim 4, characterized in that The causal representation tensor is generated by performing an intervention operation on the node attributes of the hypergraph, calculating the numerical difference before and after the intervention and writing it into the diagonal of the tensor.

6. The method according to claim 1, characterized in that In the relationship graph, a bipartite subgraph consisting of user nodes and product nodes is first extracted; multi-order power operations are performed on the normalized Laplacian matrix of the bipartite subgraph, and the convolution coefficients of each order are calculated in combination with an exponential decay kernel; the convolution coefficients of different orders are spliced ​​in sequence to obtain multi-scale features in the graph domain.

7. The method according to claim 1, characterized in that The time series embedding model is composed of a recursive neural network and a neural ordinary differential equation connected in series, wherein the output of the recursive neural network serves as the initial value of the neural ordinary differential equation.

8. The method according to claim 1, characterized in that The high-dimensional pulse vector is obtained by multiplying the time embedding representation with a random projection matrix, performing a binarization mapping through a hyperbolic tangent function and taking a sign function, and the resulting binary vector constitutes the high-dimensional pulse vector.

9. The method according to claim 1, characterized in that The generative reverse process determines a noise scheduling table according to the variance information of the cross-merchant high-dimensional vector, and periodically introduces topological chaos Monte Carlo annealing in the reverse iterative process.

10. The method according to claim 1, characterized in that The quantum optimization sampling is completed on a quantum annealing processor, and the sampled action vector and the cross-merchant high-dimensional vector are jointly input into the reinforcement learning network, wherein the reward signal of the reinforcement learning network is calculated based on user click feedback and payment feedback.

Images