Cascade real-time feedback fusion output method and device, equipment and medium

Abstract

The application relates to the technical field of data analysis, can be applied to business scenes such as financial technology and medical health, and discloses a cascaded real-time feedback fusion output method, device, equipment and medium, which comprises the following steps: collecting multi-source behavior data to generate real-time behavior flow and an offline feature set, generating an initial candidate set based on a recall channel, performing coarse sorting and alignment processing on the candidate set, inputting a deep sorting model to generate a fine candidate set, injecting an exploration candidate set through an exploration channel to generate an exploration mixed set and outputting a final result, collecting a feedback data set of the final result to update recall parameters, sorting conditions, model weights and feature generation strategies. Through the combination of multi-stage screening and real-time feedback, the application improves the timeliness and accuracy of recommendation, enhances diversity, alleviates the cold start problem, and improves the system adaptive capability while reducing the delay and resource consumption.

Description

Technical Field

[0001] This invention relates to the field of data analysis technology, and in particular to a cascaded real-time feedback fusion output method, apparatus, equipment, and medium. Background Technology

[0002] Currently, recommendation systems in the industry generally adopt a microservice-based architecture. Although they have basic stages such as recall and ranking, there are still obvious shortcomings in practical applications, and these shortcomings are prominent in different fields.

[0003] In the fintech sector, recommendation systems are commonly used for personalized financial product recommendations, insurance plan matching, and credit business push notifications. Current technologies generally rely on a single recall strategy or simple parallel recall methods during the recall phase. When faced with a large candidate set, this either results in excessively high response latency due to wasted computational resources, or the recall results are too simplistic and fail to cover the diverse financial needs of users. This limitation directly impacts the user experience in key business processes. For example, a lack of diversity in investment product recommendations may lead to user churn, while high latency can easily cause missed real-time trading opportunities. Furthermore, ranking models in financial transactions heavily rely on pre-built offline features and customer profiles, failing to capture real-time user behavior, such as fund keywords searched temporarily during a conversation or insurance products frequently browsed in a short period. This leads to a mismatch between recommendation results and the user's immediate interests, reducing the relevance of the recommendations and conversion rates.

[0004] In the healthcare sector, recommendation systems are typically used for personalized health management advice, drug recommendations, and diagnostic assistance. However, existing architectures exhibit significant shortcomings. When faced with massive health knowledge bases or drug databases, simple parallel recall mechanisms often require waiting for the slowest recall channel to complete, leading to overall response delays and failing to meet the time-sensitive requirements of medical scenarios. Furthermore, data feature processing relies excessively on historical medical records and offline health archives, failing to dynamically respond to users' real-time health behaviors, such as recently uploaded vital sign monitoring data or immediate symptom feedback. This results in recommendations being disconnected from the user's current health status, reducing the practicality and security of the recommendations. Moreover, existing medical recommendation architectures also suffer from module expansion issues. Introducing new diagnostic knowledge recall strategies or more complex ranking models often involves large-scale modifications and testing of highly coupled modules, resulting in excessively long iteration cycles and failing to meet the rapidly evolving needs of healthcare services. Summary of the Invention

[0005] The main objective of this invention is to provide a cascaded real-time feedback fusion output method, apparatus, device, and storage medium, which aims to solve the technical problems of existing recommendation systems that generally rely on offline features and fixed recall strategies, and cannot achieve dynamic fusion and feedback-driven optimization of real-time behavioral data in multi-stage processing links, resulting in lagging recommendation results, wasted resources, and insufficient exploration capabilities.

[0006] To achieve the above objectives, the present invention provides a cascaded real-time feedback fusion output method, comprising:

[0007] Collect multi-source behavioral data and item information to generate real-time behavioral streams and offline feature sets;

[0008] Based on the asynchronous triggering of the recall channel set, the recall operation is performed on the real-time behavior stream and the offline feature set, and the recall results are fused to generate an initial candidate set.

[0009] Perform a coarse sort on the initial candidate set, and generate a coarsely sorted candidate set by filtering from the initial candidate set according to the truncation condition;

[0010] The real-time behavior stream is processed to generate a real-time feature set, and the real-time feature set is aligned with the offline feature set to obtain an aligned feature set;

[0011] The coarse-ranked candidate set and the alignment feature set are input into the deep ranking model, and the fine-ranked candidate set is generated through the deep ranking model.

[0012] An exploration candidate set is injected into the fine-ranking candidate set through an exploration channel to generate an exploration hybrid set, and the final output set is generated based on the exploration hybrid set.

[0013] Collect feedback data from the final output set, and update the parameters of the recall channel set, the truncation condition for coarse ranking, the weights of the deep ranking model, and the generation strategy for the alignment feature set based on the feedback data set.

[0014] Furthermore, to achieve the above objectives, the present invention provides a cascaded real-time feedback fusion output device, comprising:

[0015] The data acquisition module is used to collect multi-source behavioral data and item information to generate real-time behavior streams and offline feature sets;

[0016] The recall module is used to asynchronously trigger a recall operation based on the recall channel set, perform recall on the real-time behavior stream and offline feature set, and fuse the recall results to generate an initial candidate set.

[0017] The coarse sorting module is used to perform coarse sorting on the initial candidate set and to filter and generate a coarsely sorted candidate set from the initial candidate set according to the truncation condition.

[0018] The feature alignment module is used to process the real-time behavior stream to generate a real-time feature set, and align the real-time feature set with the offline feature set to obtain an aligned feature set;

[0019] The fine ranking module is used to input the coarse ranking candidate set and the alignment feature set into the deep ranking model, and generate the fine ranking candidate set through the deep ranking model.

[0020] The exploration injection module is used to inject the exploration candidate set into the fine-ranking candidate set through the exploration channel, generate the exploration mixture set, and generate the final output set based on the exploration mixture set;

[0021] The feedback optimization module is used to collect feedback data sets of the final output set, and update the parameters of the recall channel set, the truncation conditions of the coarse ranking, the weights of the deep ranking model, and the generation strategy of the alignment feature set based on the feedback data sets.

[0022] Furthermore, to achieve the above objectives, the present invention also provides a computer device, the computer device including a memory, a processor, and a cascaded real-time feedback fusion output program stored in the memory and executable on the processor, wherein when the cascaded real-time feedback fusion output program is executed by the processor, it implements the steps of the cascaded real-time feedback fusion output method as described above.

[0023] Furthermore, to achieve the above objectives, the present invention also provides a computer-readable storage medium storing a cascaded real-time feedback fusion output program, wherein when the cascaded real-time feedback fusion output program is executed by a processor, it implements the steps of the cascaded real-time feedback fusion output method as described above.

[0024] Beneficial Effects: This invention relates to the field of data analysis technology and can be applied to business scenarios such as fintech and healthcare. It discloses a cascaded real-time feedback fusion output method, apparatus, device, and medium, comprising: collecting multi-source behavioral data and item information to generate a real-time behavioral stream and an offline feature set; asynchronously triggering a recall operation based on a recall channel set to fuse the recall results and generate an initial candidate set; performing coarse sorting on the initial candidate set and filtering according to truncation conditions to generate a coarsely ranked candidate set; processing the real-time behavioral stream to generate a real-time feature set and aligning it with the offline feature set to obtain an aligned feature set; inputting the coarsely ranked candidate set and the aligned feature set into a deep ranking model to generate a finely ranked candidate set; injecting an exploration candidate set into the finely ranked candidate set through an exploration channel to generate an exploration hybrid set and generating a final output set based on this set; collecting feedback datasets from the final output set and merging them; and updating the recall channel set parameters, coarse sorting truncation conditions, deep ranking model weights, and the generation strategy of the aligned feature set based on the feedback. This invention achieves layer-by-layer filtering of recall, coarse ranking, and fine ranking through multi-stage cascading. It improves the timeliness of ranking by dynamically aligning real-time behavioral data with offline features, enhances recommendation diversity and solves the cold start problem by exploring channels, and then drives updates to the recall channel, ranking model, and feature strategy through feedback data sets, forming a closed-loop optimization. This not only reduces computational resource waste and latency but also improves the accuracy and diversity of recommendation results, enabling the recommendation system to be adaptive and continuously optimized. Attached Figure Description

[0025] The present invention will be further described below with reference to the accompanying drawings and embodiments. In the accompanying drawings:

[0026] Figure 1 This is a schematic diagram of an application environment for the cascaded real-time feedback fusion output method in one embodiment of the present invention;

[0027] Figure 2 This is a flowchart illustrating an embodiment of the cascaded real-time feedback fusion output method of the present invention;

[0028] Figure 3 This is a schematic diagram of the functional modules of a preferred embodiment of the cascaded real-time feedback fusion output device of the present invention;

[0029] Figure 4 This is a schematic diagram of the structure of a computer device according to an embodiment of the present invention;

[0030] Figure 5 This is another structural schematic diagram of a computer device according to one embodiment of the present invention. Detailed Implementation

[0031] It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of the invention.

[0032] The cascaded real-time feedback fusion output method provided in this embodiment of the invention can be applied to, for example... Figure 1 In this application environment, the client communicates with the server via a network. The server can collect multi-source behavioral data and item information from the client to generate real-time behavioral streams and offline feature sets. Based on the recall channel set, it asynchronously triggers recall operations, fuses recall results to generate an initial candidate set, performs coarse sorting on the initial candidate set, and filters it according to truncation conditions to generate a coarse-ranked candidate set. It processes the real-time behavioral stream to generate a real-time feature set and aligns it with the offline feature set to obtain an aligned feature set. The coarse-ranked candidate set and the aligned feature set are input into a deep ranking model to generate a fine-ranked candidate set. An exploration channel is used to inject an exploration candidate set into the fine-ranked candidate set to generate an exploration hybrid set, and a final output set is generated based on this set. The feedback dataset of the final output set is collected and merged to update the recall channel set parameters, coarse sorting truncation conditions, deep ranking model weights, and the generation strategy of the aligned feature set based on the feedback. This invention achieves layer-by-layer filtering of recall, coarse sorting, and fine sorting through multi-stage cascading. It improves the timeliness of ranking by combining real-time behavioral data and offline feature dynamic alignment, enhances the diversity of recommendations and solves the cold start problem through the exploration channel, and drives the update of recall channels, ranking models, and feature strategies through the feedback data set, forming a closed-loop optimization. This not only reduces computational resource waste and latency but also improves the accuracy and diversity of recommendation results, enabling the recommendation system to adapt and continuously optimize. The client can be, but is not limited to, various personal computers, laptops, smartphones, tablets, and portable wearable devices. The server can be implemented using a standalone server or a server cluster consisting of multiple servers. The invention will be described in detail below through specific embodiments.

[0033] Please see Figure 2 , Figure 2 This is a flowchart illustrating an embodiment of the cascaded real-time feedback fusion output method provided by the present invention. It should be noted that although the logical order is shown in the flowchart, in some cases, the steps shown or described may be performed in a different order than that shown here.

[0034] like Figure 2 As shown, the cascaded real-time feedback fusion output method proposed in this invention includes the following steps:

[0035] S10 collects multi-source behavioral data and item information to generate real-time behavioral streams and offline feature sets;

[0036] In this embodiment, the process of collecting multi-source behavioral data and item information includes user interaction data in different scenarios, such as click records, search queries, browsing history, and dwell time. These data typically originate from user-end log systems or event tracking systems. Behavioral data needs to be parsed and integrated in chronological order to ensure the temporal sequence of user actions is preserved during processing. To guarantee data integrity, behavioral data collection needs to cover different devices and terminals to avoid data loss across different device usage scenarios. Item information refers to the attribute information of the candidate object itself, typically including static and dynamic attributes. Static attributes refer to content that does not change over time, such as category tags, item descriptions, and structured basic attribute fields. Dynamic attributes are historical statistical indicators associated with user behavior, such as exposure counts, click counts, conversion rates, or ratings.

[0037] The generation of real-time behavior streams involves parsing and filtering collected behavioral data, transforming it into structured streaming data that can be processed in real time. This typically requires sorting by event timestamps to form a continuous sequence of events. The significance of real-time behavior streams lies in capturing users' immediate interests and intentions, ensuring that the recommendation process can quickly respond to the latest user behavior. During the generation of real-time behavior streams, latency must be kept within an acceptable range; therefore, a common implementation method is to use stream processing frameworks to perform incremental aggregation of high-frequency data.

[0038] The generation of offline feature sets relies on the long-term accumulation of item information and historical behavior data. Basic item attributes are typically encoded after direct database queries, transforming categorical data into vector form through one-hot encoding or embedding representation. Historical statistical indicators of items need to be normalized or standardized to ensure that numerical data of different dimensions can be uniformly incorporated into the model input. To enable the simultaneous use of static and dynamic features, offline feature sets are often concatenated or merged as high-dimensional vectors, forming a feature set that can be directly input into ranking or recall models.

[0039] In implementation, real-time behavior streams can be constructed using different technical approaches. For example, a distributed log collection system can be used to collect data from front-end and back-end event tracking points into a message queue, followed by event cleaning and aggregation using a stream processing engine. Alternatively, event sequences can be directly generated through a database trigger mechanism. For offline feature sets, batch processing can be used to update item data at fixed time intervals, or a near-real-time micro-batch update mechanism can be employed to improve data timeliness. In terms of encoding, categorical fields can be represented by dense vectors through embedding representations, or continuous fields can be discretized through bucketing. For processing historical statistical indicators of items, sliding window statistics can be used, or a weighted decay mechanism can be introduced to give higher weight to recent behaviors, reflecting the timeliness of user interests.

[0040] When adapting to different scenarios, high-concurrency scenarios require horizontal scaling of the stream processing cluster to ensure the throughput of real-time behavior streams. Low-frequency update scenarios, such as medication recommendations in the healthcare field, can reduce the real-time update frequency to ensure efficient use of computing resources. In the financial sector, if risk control recommendations are involved, highly sensitive features such as transaction history or credit scores need to be added to the offline feature set. The processing of these features must comply with regulations, therefore, anonymization and encryption methods are used before they are added to the offline feature set.

[0041] This embodiment collects multi-source behavioral data and item information to generate real-time behavioral streams and offline feature sets. This allows the system to simultaneously retain both the user's immediate operational intent and historically accumulated features, ensuring both timeliness and stability during computation. This reduces the discrepancy between recommendation results and actual user needs, avoiding lag caused by relying solely on outdated data, and also preventing instability caused by relying solely on real-time data, thus balancing accuracy and response speed.

[0042] S20, based on the recall channel set, asynchronously trigger the recall operation, perform recall on the real-time behavior stream and offline feature set, and fuse the recall results to generate an initial candidate set;

[0043] In this embodiment, the recall channel set is a combination of various recall strategies, with each channel corresponding to a specific recall logic. For example, the collaborative filtering recall channel focuses on generating a candidate set by utilizing the similarity between users or between users and items; the vector recall channel uses an embedding model to map user behavior and item features to the same vector space, and obtains a candidate set through similarity retrieval; the hotspot recall channel quickly provides high-frequency items based on global item popularity or timeliness indicators.

[0044] Asynchronous triggering refers to starting multiple recall channels in parallel at the same time, but the channels are not required to complete synchronously. Instead, the results of completed recalls are collected first. This avoids delays in the generation of overall results due to slow responses from individual channels. Asynchronous triggering requires a channel status monitoring mechanism to be maintained at the system level. When the execution time of a certain channel exceeds a set threshold, the execution of that channel can be interrupted to ensure that the overall latency is not affected.

[0045] Real-time behavior streams and offline feature sets are used as input signals during the recall process. Real-time behavior streams provide characteristics of the user's current interactions, such as recently clicked items or currently entered queries, reflecting the user's immediate interests. Offline feature sets supplement long-term accumulated statistical attributes, such as historical preference categories and the long-term popularity of items. The recall channel needs to utilize both types of inputs simultaneously during computation, ensuring that the candidate set considers both immediate interests and long-term preferences.

[0046] The fusion of recall results refers to merging the subsets of items generated by each recall channel. Since the coverage of different channels overlaps, deduplication is required after merging to prevent the same item from appearing repeatedly in multiple channels. The final set is the initial candidate set, which will be further processed in the subsequent sorting stage.

[0047] In implementation, various strategies can be combined to construct a set of recall channels. This can include a combination of collaborative filtering, vector retrieval, and hotspot channels, or, depending on business needs, rule-based or knowledge graph-based recall channels. Asynchronous triggering can be implemented using a distributed computing framework, pushing real-time behavior streams and offline feature sets to the computing nodes of each channel via message queues. Each channel independently calculates its results and returns them to the result merging module. Alternatively, a microservice architecture can be used, with each recall channel corresponding to an independent service, uniformly triggered and collected by a scheduling module.

[0048] During the merging phase, a priority merging approach can be used, prioritizing items that appear repeatedly in multiple channels to reflect the multi-channel reliability of items. Alternatively, a weighted merging mechanism can be employed, assigning different weights to results from different channels before merging and deduplication. For applications with high latency requirements, a maximum waiting time can be set; if this timeout is exceeded, incomplete channels are skipped to ensure the timeliness of the overall results.

[0049] This embodiment, through asynchronous triggering based on a recall channel set, avoids impacting the diversity and timeliness of recommendations due to insufficient results from a single channel or excessive latency in a particular channel. Integrating real-time behavior streams and offline feature sets balances users' immediate interests and long-term preferences, generating an initial candidate set that is both diverse and tailored to individual user needs. Merging and deduplication operations further ensure the integrity and rationality of the candidate set, thus providing high-quality input for subsequent ranking processes.

[0050] S30, perform coarse sorting on the initial candidate set, and generate a coarsely sorted candidate set from the initial candidate set according to the truncation condition;

[0051] In this embodiment, coarse ranking refers to a rapid screening and preliminary sorting of candidate items in the recommendation system processing flow, after the initial candidate set has been generated through multi-channel recall. This is achieved using a lightweight ranking model and limited features, eliminating most irrelevant or low-relevance items with low computational cost, and retaining content more likely to be accepted by users in the next stage. The core objective of coarse ranking is to achieve efficient filtering with low computational resources, thereby reducing the computational burden on the subsequent fine ranking model. The goal of coarse ranking is to quickly screen items in the initial candidate set to reduce the computational overhead of the subsequent fine ranking stage. The initial candidate set is typically large; directly entering a complex deep ranking model without screening would lead to computational delays and resource waste. Coarse ranking relies on a lightweight computational model to evaluate the relevance of each candidate item.

[0052] The implementation typically involves the following steps. First, basic features related to users and items are extracted from the initial candidate set. These features are often low-dimensional and computationally inexpensive, such as static attributes of items and basic user profile data. Second, these features are input into a lightweight ranking model, such as one based on logistic regression, gradient boosting trees, or a simplified shallow neural network, to calculate an initial screening score for each candidate. Third, the system sorts the candidate items in descending order based on these initial screening scores, forming a ranked list. Simultaneously, to balance system real-time performance and load considerations, truncation conditions, such as a baseline threshold, are set to control the number of candidates retained. If the system load is high, the number of candidates can be dynamically reduced to alleviate computational pressure; if the system load allows, the threshold can be relaxed to retain more candidate entries to increase diversity.

[0053] Ultimately, the coarse ranking selects and retains a subset of items, forming a coarse candidate set. This process ensures that the subsequent fine ranking model only needs to process a relatively small candidate set, thus saving computational resources, and also guarantees a basic match between user interests and item relevance. In other words, the role of coarse ranking is to achieve a balance between efficiency and effectiveness while ensuring recommendation accuracy and diversity.

[0054] Truncating conditions are rules used to control the size of the coarse-ranking results. They typically include a predefined threshold, such as retaining a certain number of top-ranked items. Truncating conditions can be fixed values ​​or dynamically adjusted based on the system's real-time load, ensuring that the system maintains the diversity of recommended results without excessively consuming resources under high load.

[0055] The set of basic features for an item typically includes static features such as item category, tags, posting time, and price range. These features can reflect the basic attributes of the item with low computational cost. The set of static features for a user includes information such as long-term interest tags, age group, geographic distribution, and long-term consumption preferences, which are used to estimate the long-term matching degree between items and users.

[0056] Lightweight ranking models are fast models that differ from deep ranking models. They can employ gradient boosting trees, logistic regression, or linear models based on sparse features. Lightweight ranking models take as input a set of basic item features and a set of user static features, and output an initial score to measure the preliminary ranking position of the items.

[0057] After calculating the scores of the items, the system sorts all candidate items in descending order according to their initial scores, forming a sorted item sequence. This sorted item sequence is an ordered data structure, ensuring that the most relevant items are prioritized for inclusion in the coarse-ranked candidate set. Finally, based on the updated truncation criteria, the top-ranked items are selected from the sorted item sequence to form the coarse-ranked candidate set.

[0058] A fixed threshold can be used to implement the truncation condition, for example, keeping only the top 1000 items in the coarse-ranked candidate set. Alternatively, a dynamic threshold adjustment method can be used, combined with real-time system load metrics such as CPU utilization, memory usage, and request queue length, to reduce the size of the candidate set when the load is high and expand it appropriately when the load is low, thereby improving the coverage and diversity of recommendations.

[0059] Lightweight ranking models can calculate the matching probability between items and users based on logistic regression, or they can use gradient boosting trees to capture the combined relationships between non-linear features. In some implementations, online learning mechanisms can also be employed, enabling the lightweight model to update parameters in a short time to adapt to rapid changes in user interests.

[0060] Regarding feature input, you can use only the basic features of the item and the static features of the user, or you can extend it by introducing a small number of real-time features, such as the category label of the user's most recent click, but you will not introduce computationally intensive sequence features to ensure computational efficiency.

[0061] This embodiment significantly reduces the number of items entering the fine-sorting stage by performing a coarse sort on the initial candidate set, thereby reducing computational resource consumption and model inference latency. The dynamic adjustment mechanism of the truncation condition allows the system to flexibly control the output scale based on the running status, avoiding excessively long response times under high concurrency. The use of a lightweight sorting model ensures that the coarse sorting stage can be executed quickly while maintaining the relevance of the recommendation results to a certain extent.

[0062] S40, process the real-time behavior stream to generate a real-time feature set, and align the real-time feature set with the offline feature set to obtain an aligned feature set;

[0063] In this embodiment, real-time behavior streams refer to dynamic data sequences generated by users during interactions, typically including click records, search keywords, browsing time, and interaction frequency. Compared to offline feature sets, real-time behavior streams are characterized by high timeliness and rapid changes, therefore requiring segmentation and serialization to transform them into effective features that can be input into the model.

[0064] To generate a real-time feature set from real-time behavior streams, user behavior data needs to be segmented along a time dimension, such as establishing time windows based on minutes, hours, or session boundaries. The sequence of behaviors within each time window can be represented as vectors using sequence encoding. For example, click history can be converted into sparse vectors of item categories, search keywords can be converted into semantic vectors using an embedding model, and browsing duration can be normalized into numerical features. The resulting real-time feature vector sequence accurately reflects a user's immediate interests within a specific time period.

[0065] Offline feature sets typically include long-term collected static attributes, such as user geographic distribution, age group, and historical preference tags, as well as item inherent attributes and historical statistical indicators. Because real-time and offline features differ in time scale, dimensionality, and representation, alignment is required. Alignment includes both temporal alignment and dimensionality alignment. Temporal alignment ensures temporal consistency by matching real-time behavior windows with offline statistical time periods; for example, mapping click behavior from the most recent hour to statistical features from the past month. Dimensional alignment, on the other hand, transforms features from different sources into a unified representation space through standardization and dimensionality reduction, preventing scale differences or redundant features from affecting model input performance.

[0066] Finally, the dimension-aligned feature set is concatenated with the item's static attributes to form an aligned feature set. This set contains both real-time user behavior information and retains long-term profiles and basic item attributes, achieving a combination of timeliness and stability.

[0067] In one implementation, real-time behavior streams can be processed in real time using streaming computing frameworks such as Flink or Spark Streaming, encoding user interaction events into feature vectors and generating real-time feature sets in a fixed time window manner.

[0068] In another implementation, session-level feature extraction can be used, which encodes the behavioral sequence of a complete session into a vector to capture short-term user intent. Session segmentation can be based on interaction intervals; for example, inactivity exceeding 30 minutes can be considered a new session.

[0069] In the alignment process, a time-sliding window mechanism can be used to align real-time features with historical features according to timestamps, such as combining recently clicked item categories with offline long-term user preference tags. Dimensionality reduction algorithms, such as principal component analysis or feature selection methods, can also be used to eliminate redundant features and reduce the input dimension. Different standardization methods can also be selected for different system scenarios; for example, Z-score standardization can be used in scenarios with large differences in data distribution, while Min-Max normalization can be used in sparse feature scenarios.

[0070] This embodiment generates a real-time feature set and aligns it with an offline feature set, simultaneously incorporating both short-term user interests and long-term profiles at the model input level, thus improving the relevance of recommendation results. The introduction of real-time features prevents recommendations from lagging behind users' immediate needs, while the introduction of offline features ensures the stability of the recommendations. The alignment operation resolves the inconsistency between real-time and historical data in terms of time and dimension, making the feature input more complete and reasonable, and enhancing the model's ability to capture user behavior.

[0071] S50, input the coarse-ranked candidate set and the alignment feature set into the deep ranking model, and generate the fine-ranked candidate set through the deep ranking model;

[0072] In this embodiment, the coarse-ranked candidate set is a set of items obtained through preliminary sorting and filtering. It has typically been processed by a lightweight ranking model, but its ranking accuracy remains limited. The aligned feature set contains a unified representation of the user's real-time behavioral features and long-term offline features in terms of both dimension and time. Using both as input, a complete set of item-side and user-side features can be provided to the deep ranking model.

[0073] Deep ranking models typically consist of a feature input layer, an interaction modeling layer, and an output layer. The feature input layer receives a set of dynamic feature vectors for items from the coarse-ranked candidate set, as well as user feature sets and context feature sets from the alignment feature set. User feature sets usually include historical behavior vectors and interest preference tags, while context feature sets include time, geographic location, and device information. The set of dynamic feature vectors for items comes from historical statistical indicators, recent interaction data, or embedded vector representations of the items.

[0074] The interaction modeling layer employs an attention neural network to weight the user feature set and the item dynamic feature vector set, generating an item interaction weight matrix. The attention mechanism learns the correlations between different features and dynamically adjusts the matching degree between each item and user behavior, thereby more accurately quantifying the user's potential interests. Based on this weight matrix, a weighted fusion operation is performed on the item dynamic feature vector set to obtain a refined feature vector set, which centrally reflects the interaction strength between the user's immediate interests and candidate items.

[0075] The output layer is typically a fully connected layer that maps the set of fine-ranking feature vectors into a score space, generating a fine-ranking score for each item. The fine-ranking score reflects the relevance of the item to user preferences and serves as the basis for subsequent descending sorting and truncation filtering. Finally, items are arranged from highest to lowest fine-ranking score, and a preset fine-ranking threshold is used to select a top-ranking subset, forming a candidate set for fine-ranking.

[0076] In one implementation, the deep ranking model can adopt a DIN (Deep Interest Network) based structure, taking the user's historical click sequence as input and capturing the user's interest intensity in candidate items in the current context through an attention mechanism. The dynamic feature vectors of items and user feature vectors are matched in the attention layer, and the weighted result is input into a fully connected layer to calculate the fine ranking score.

[0077] In another implementation, a DIEN (Deep Interest Evolution Network) structure can be adopted, introducing user interest evolution modeling. Real-time behavior sequences are encoded through recurrent neural networks or gating units to form dynamic interest states. These dynamic interest states interact with candidate items to obtain a refined ranking score that better reflects real-time preferences.

[0078] A Transformer architecture can also be used to globally model user feature sets, leveraging multi-head attention to simultaneously capture the interaction relationships between users and candidate items across different semantic dimensions. For a large number of candidate items, feature hashing or sparse embedding can be introduced into the input layer to reduce computational overhead and ensure real-time performance.

[0079] This embodiment improves the accuracy of recommendation results by inputting the coarse-ranked candidate set and the aligned feature set into the deep ranking model, effectively integrating users' long-term interests, immediate behaviors, and contextual environment during the ranking stage. The introduction of an attention neural network ensures dynamic modeling of the contribution of different features, avoiding biases caused by fixed weights. The generation of fine-ranking scores allows candidate items to be further refined according to personalized matching degrees, reducing the probability of irrelevant items entering the final output set and improving the overall system response efficiency and user experience.

[0080] S60, inject the exploration candidate set into the fine-ranking candidate set through the exploration channel to generate the exploration mixture set, and generate the final output set based on the exploration mixture set;

[0081] In this embodiment, the refined candidate set is the set of items generated after calculation by the deep ranking model. It already has a high matching degree, but lacks the ability to cover new users and new items. The introduction of the exploration candidate set is to enhance the system's exploration capability and avoid the recommendation results being limited to the user's known interests. The task of the exploration channel is to select items that have not been widely exposed from the item library or incremental data, and generate the exploration candidate set through specific strategies.

[0082] When the exploration candidate set and the refined candidate set are merged, a combined item set is formed. However, duplicate items may exist within this set, so a deduplication operation is needed to ensure that each item appears only once. The result after deduplication is the exploration hybrid set, which retains both refined and exploration candidate items. To ensure ranking consistency, comparable scores need to be introduced for exploration candidate items. Typically, refined candidate items retain their refined ranking score, while exploration candidate items are assigned an exploration confidence score.

[0083] After obtaining the dual-source scores, the exploration mix is ​​uniformly defined as the output score, which is used for ranking. The output score, numerically speaking, is either a fine-grained ranking score or an exploration confidence score, depending on the item's source. The exploration mix is ​​sorted in descending order based on the output scores, ensuring a fair comparison of items from different sources. Then, using a preset final output quantity threshold, a subset of top-ranked items is extracted from the ranking results to generate the final output set. This final output set is the result displayed to the user by the recommendation system, containing both highly relevant fine-grained items and items with exploration value, thus balancing accuracy and diversity.

[0084] In one implementation, the exploration channel can prioritize long-tail items or cold-start items as the exploration candidate set based on item popularity distribution and user-unexposed records. For example, for a newly added item, the exploration confidence score can be estimated using a small number of cold-start features (such as text description and basic classification information).

[0085] In another implementation, the exploration channel can employ a multi-armed slot machine model, combining the selection of exploration candidates with user feedback. Each exploration candidate, after being displayed, updates its exploration confidence score based on user clicks, skips, or negative feedback. This dynamic adjustment mechanism maintains a balance between exploration and exploitation.

[0086] The threshold for the final output quantity can also be adjusted for different application scenarios. For example, in real-time recommendation scenarios, the threshold can be set to a smaller value to ensure low-latency response; while in offline batch recommendation or content push scenarios, the threshold can be set to a larger value to provide richer candidate results.

[0087] This embodiment addresses the information cocoon problem caused by solely relying on the refined ranking result by introducing an exploration candidate set and merging it with the refined ranking candidate set, thereby improving the diversity of recommendation results. Through deduplication and dual-source score normalization mechanisms, fairness in the ranking of refined and exploration items is ensured. The final output set generation balances accurate capture of user interests with the discovery of potential interests, enabling the system to maintain high recommendation quality while also exhibiting good adaptability and scalability in scenarios with new users and new items.

[0088] S70, collect the feedback data set of the final output set, and update the parameters of the recall channel set, the truncation condition of the coarse ranking, the weight of the deep ranking model, and the generation strategy of the alignment feature set according to the feedback data set.

[0089] In this embodiment, the final output set is an ordered set of items presented to the user, derived from the sorting and truncation results of the exploration hybrid set. It includes uniquely identifiable item identifiers, exposure timestamps, booth locations, and source tags, used for feedback alignment and impact attribution in subsequent stages. The feedback data set is a collection of interaction records built around the final output set, derived from user events such as clicks, dwell times, add-to-cart actions, favorites, dislikes, blocks, skips, and shares generated during the display period, along with contextual data associated with these events. To ensure traceability, each interaction record carries a user identifier, item identifier, booth location, exposure timestamp, interaction timestamp, and client environment information. These are aligned one-to-one or one-to-many with the exposure logs of the final output set to form a feedback data set that can be updated. To reduce statistical bias, the feedback data set incorporates session boundaries, frequency control markers, and bot removal markers during construction to ensure that interactions belong to genuine user behavior.

[0090] The parameters of the recall channel set are configurable variables that adjust channel-level behaviors such as collaborative filtering recall channels, vector recall channels, and hotspot recall channels. These include channel weights, intra-channel similarity thresholds, recall caps, asynchronous timeout thresholds, and result deduplication strategy indicators. These parameters originate from the preceding recall execution and fusion logic. Updating these parameters requires aligning the feedback data set with the channel source tags to quantify the contribution of each channel, and then adjusting the channel weights and intra-channel thresholds accordingly. The coarse-ranking truncation condition is a strategy used in the coarse-ranking stage to control the number of channels sent to the fine-ranking stage. It includes the baseline truncation threshold in the initial truncation condition and the updated truncation condition formed during runtime. This condition originates from the comprehensive constraints on system load and user behavior during the coarse-ranking stage. In the feedback dimension, skip rate, early exit rate, and location click rate are used to directionally correct the quantity threshold, achieving a balance between latency and effectiveness in the coarse-ranking behavior.

[0091] The weights of the deep ranking model are a set of learnable parameters used to generate the fine-grained ranking score, derived from the preceding training process and the online incremental learning process. After mapping the feedback data set to positive and negative samples, delayed alignment is performed according to the exposure time window and the booth position, which triggers the weight update. To suppress parameter drift, a frozen subspace or regularization term needs to be introduced during weight updates so that changes in new weights do not disrupt existing stability. The strategy for generating the aligned feature set involves the execution logic of constructing, aligning, and concatenating the real-time and offline feature sets, including time window granularity, feature space standardization methods, dimensionality reduction methods, static feature selection lists, and feature weight allocation. This strategy originates from the preceding alignment process; in the feedback dimension, the contribution of each feature dimension to the consistency between prediction and actual interaction is statistically measured, and the time window, standardization method, and feature weight allocation are adjusted accordingly to make the subsequent aligned feature set more closely reflect real-time interests.

[0092] The feedback-to-update process establishes a seamless link for the four types of objects mentioned above. First, an exposure index is created for the final output set, giving each exposure a globally unique key. This key is then used to align click, dwell, skip, and negative feedback events, generating a feedback data set. Next, based on source tags, the feedback is split into a recall channel set. Recall click-through rate, recall effective impression rate, and channel contribution are aggregated by channel, and channel weights and asynchronous timeout thresholds are updated. For the coarse ranking truncation condition, the skip behavior frequency and real-time load metrics are used to directionally increase or decrease the baseline quantity threshold, forming the updated truncation condition. For the weights of the deep ranking model, positive and negative samples carrying exposure location information and time alignment are used for small-step incremental training or sliding window relearning, while early stopping and rollback protection are employed to avoid overfitting or short-term shocks. For the strategy of generating the aligned feature set, feature weights and time windows are finely adjusted based on contribution, and a new round of alignment configuration is redistributed to ensure that the subsequent ranking input distribution remains consistent with the user's latest interests.

[0093] In one implementation, the exposure index of the final output set is generated by hashing the user identifier, session identifier, exposure timestamp, and booth location, ensuring the distinguishability of the same items in different booths within the same display stream. Exposure logs and interaction logs are written to the real-time message queue with the same sharding key to ensure consistent downstream alignment timing. De-bot marking is achieved through a combined judgment of abnormal device fingerprint frequency, extremely short dwell times, and extremely high scrolling rates; marked records are filtered or downweighted during the feedback data set construction phase. Session boundaries are determined jointly by a long silence threshold and page switching events to avoid cross-session contamination.

[0094] For parameter updates of the recall channel set, Bayesian smoothing can be applied to the exposure click-through rate and location click-through rate within each channel to obtain a robust channel contribution, which is then written back to the channel weights using normalized weights. When the contribution of a channel significantly decreases within a continuous time window, the elimination intensity of the asynchronous timeout threshold is increased simultaneously to prevent slow channels from delaying the overall response. The vector recall channel introduces a temperature term when updating the similarity threshold to suppress similarity distribution drift caused by short-term hotspots. The hotspot recall channel introduces a deduplication indicator when updating the recall upper limit to prevent high-frequency items from occupying excessive candidate quotas.

[0095] To address the truncation condition for coarse sorting, a piecewise linear mapping can be used to update the baseline threshold, with skip behavior frequency and real-time load metrics as independent variables. This lowers the threshold when the load increases or the skip frequency rises, and raises it during windows with low load and increased click-through rates. To avoid threshold oscillations, a easing coefficient and upper / lower limit clamping mechanisms are introduced, and the threshold variation is corrected using exposure position signals to ensure a stable user experience.

[0096] For the weights in the deep ranking model, a positive and negative sample queue can be constructed based on clicks and negative feedback after exposure alignment. Incremental training is performed using a small learning rate and sliding window resampling. When the sampling distribution differs significantly from the historical distribution, distillation transfer is enabled, using the historical model as the soft target of the teacher network output to mitigate drastic parameter updates caused by short-term interest fluctuations. To ensure online security, online updates are carried out using shadow copies, and the main link is switched only after dual-track comparison and rollbackable release. If the main indicators of A / B splitting deteriorate, automatic rollback to stable weights is triggered.

[0097] For the generation strategy of aligned feature sets, prediction consistency metrics can be calculated based on feature dimensions, such as contribution based on permutation importance or residual sensitivity. When the contribution of a certain dimension is low for a long time and causes significant computational overhead, its feature weight can be reduced or the time window can be shortened. When the contribution of a certain type of static feature increases in a segmented population, the weight of that type of feature can be increased separately for that population. The adjustment of the time window can be achieved by multi-granularity parallel generation and online routing switching, that is, maintaining multiple window granularities of fine and medium simultaneously, and routing to different window configurations according to population strategy and scenario strategy to avoid frequent full recalculation. The adjustment of standardization and dimensionality reduction methods supports hot switching. First, a temporary aligned feature set under the new configuration is generated, and then fed in parallel with the old configuration to the shadow copy of the deep ranking model to evaluate the distribution differences and indicator benefits before the formal switch is performed.

[0098] Cross-module consistency protection can also be introduced. When the parameters of the recall channel set drop significantly, the updated cutoff condition of the coarse ranking can be temporarily increased to prevent a sudden drop in the candidate size. When the weights of the deep ranking model undergo large-scale updates, further adjustments to the generation strategy of the alignment feature set can be postponed to avoid instability caused by simultaneous changes in the input distribution and model representation. To suppress short-period noise, exponential sliding aggregation can be used on the feedback data set, assigning higher weights to closer windows and providing stabilization references to farther windows. The aggregation result simultaneously drives the updates of channel parameters, cutoff conditions, weights, and strategies.

[0099] This embodiment achieves adaptive adjustment for real-time interests without altering the existing processing chain by merging the interactions generated by the final output set into a feedback data set and updating the parameters of the recall channel set, the truncation conditions of the coarse ranking, the weights of the deep ranking model, and the generation strategy of the alignment feature set in a linked manner. The weights and thresholds of the recall layer change with feedback, reducing invalid recalls and improving diversity; the number of coarse ranking truncations converges synchronously with load and skipping behavior, reducing overall latency and invalid computation; the fine ranking weights iterate under stability protection, continuously approaching the latest interest distribution; the time window and weight allocation of the alignment features are adjusted according to contribution, ensuring consistency between input representation and user behavior.

[0100] This invention relates to the field of data analysis technology and can be applied to business scenarios such as fintech and healthcare. It discloses a cascaded real-time feedback fusion output method, apparatus, device, and medium, comprising: collecting multi-source behavioral data and item information to generate a real-time behavioral stream and an offline feature set; asynchronously triggering a recall operation based on a recall channel set to fuse the recall results and generate an initial candidate set; performing coarse sorting on the initial candidate set and filtering according to truncation conditions to generate a coarsely ranked candidate set; processing the real-time behavioral stream to generate a real-time feature set and aligning it with the offline feature set to obtain an aligned feature set; inputting the coarsely ranked candidate set and the aligned feature set into a deep ranking model to generate a finely ranked candidate set; injecting an exploration candidate set into the finely ranked candidate set through an exploration channel to generate an exploration hybrid set and generating a final output set based on this set; collecting feedback datasets from the final output set and merging them to update the recall channel set parameters, coarse sorting truncation conditions, deep ranking model weights, and the generation strategy of the aligned feature set based on the feedback. This invention achieves layer-by-layer filtering of recall, coarse ranking, and fine ranking through multi-stage cascading. It improves the timeliness of ranking by dynamically aligning real-time behavioral data with offline features, enhances recommendation diversity and solves the cold start problem by exploring channels, and then drives updates to the recall channel, ranking model, and feature strategy through feedback data sets, forming a closed-loop optimization. This not only reduces computational resource waste and latency but also improves the accuracy and diversity of recommendation results, enabling the recommendation system to be adaptive and continuously optimized.

[0101] In one embodiment, step S10 includes:

[0102] S101, collect click event stream, search event stream and page dwell event stream from user interaction logs;

[0103] S102, the click event stream, search event stream and page dwell event stream are aggregated by time window to generate a real-time behavior stream;

[0104] S103, Extract the set of basic attributes of items and the set of historical statistical indicators of items from the item database;

[0105] S104, Perform discrete feature encoding operation on the set of basic attributes of the item to generate a set of static feature vectors of the item;

[0106] S105, Perform numerical normalization on the set of historical statistical indicators of the items to generate a set of dynamic feature vectors of the items;

[0107] S106, merge the set of static feature vectors of the items and the set of dynamic feature vectors of the items to form an offline feature set.

[0108] In this embodiment, the click event stream, search event stream, and page dwell event stream originate from the same interactive data collection link, each carrying user identifier, session identifier, item identifier, booth location, event time, exposure time, page identifier, and client environment fields. The click event stream records the correspondence between click targets and booth locations, originating from page click monitoring and redirect interception; the search event stream records the search term sequence and search trigger context, originating from search box input and submission interception; the page dwell event stream records the page visibility period and scroll depth, originating from visibility changes and scroll monitoring. The three types of events are aggregated using a unified deduplication key at the entry point to remove duplicate and jittery reports. The deduplication key includes user identifier, session identifier, item identifier, booth location, and event time. To ensure temporal consistency, event time and processing time are marked in parallel, and downstream processing is driven by event time.

[0109] Time window aggregation executes simultaneously on click event streams, search event streams, and page dwell event streams. Window types can include scrolling windows, sliding windows, and session-based windows. Window levels are determined by a late arrival threshold and an advance interval. Late data within the level is merged into the current window, while data exceeding the level enters a compensation window and is distinguished downstream by a flag. Aggregation includes behavior sequence concatenation, ordered index allocation, cross-stream alignment, and session boundary marking. Ordered index allocation generates sequence numbers after sorting by event time. Cross-stream alignment uses exposure time alignment as a benchmark, aligning clicks, searches, and dwells within the same exposure context. The window output structure forms a real-time behavior stream, with fields covering user identifier, session identifier, time window identifier, behavior sequence, exposure context, and deduplication flag. The real-time behavior stream ensures that a single user and single session maintains an ordered sequence within the window, facilitating immediate use for subsequent retrieval and sorting.

[0110] The basic attribute set for items comes from the master data and extended tables of the item database, including stable attributes such as category, brand, tags, source channel, author or publisher, publication time, and content format. This set is marked with version numbers and uses a slowly changing dimension management method to save multiple version snapshots. During querying, the closest valid version is located by exposure time to avoid inconsistencies in attribute backtracking. The historical statistical indicator set for items comes from the behavior summary table, including exposure count, click count, favorite count, add-to-cart count, purchase count, skip count, share count, and conversion ratio. It is summarized hierarchically by time granularity and audience dimension to form a multi-granularity indicator view. To avoid indicator fluctuations caused by short-term noise, smoothing weights and confidence interval markings are introduced into the historical indicators during aggregation for downstream use to weigh.

[0111] Discrete feature encoding is performed on categorical and enumerable fields in the item's basic attribute set. Encoding methods can include dictionary indexing, mapping strings or categories to stable indexes; hashing, using fixed bucket capacity to hold high-cardinality numeric segments and avoiding online vocabulary expansion; or target encoding, where historical statistical indicators drive the mapping from categories to numerical space. Encoding outputs are stored as sparse or dense vectors. Vector dimensions, bucket capacity, and conflict handling strategies are distributed and versioned through a configuration center. Out-of-Voice (OOV) processing uses dedicated buckets or rollback indexes to ensure new categories can be encoded in the initial deployment phase without blocking the process. After encoding, a static feature vector set for the item is generated, using the item identifier and version number as a combined primary key to ensure a one-to-one correspondence with the master data snapshot.

[0112] Numerical normalization is performed on numerical fields in the historical statistical indicator set of items. Normalization methods can include linear scaling to bring indicators with different dimensions into a uniform range; robust scaling to suppress the influence of extreme values ​​using quantiles; and logarithmic or Box-Cox transformations to mitigate long-tail distributions. Normalization parameters are trained and distributed in buckets according to time granularity and category dimension. The parameter effectiveness period and lag window are controlled by configuration to avoid frequent fluctuations due to short-term volatility. The normalization result is output as a set of dynamic feature vectors for items, maintaining a one-to-one mapping with the original indicators, and recording the parameter version and effectiveness time for easy backtracking and auditing.

[0113] The static feature vector set and the dynamic feature vector set of items are merged to form an offline feature set. The merging key is the item identifier and version number. The merging strategy is left alignment and default padding for missing dimensions. Default padding can use the mean, median, or the last valid value. Different strategies can be configured for different dimensions. Before merging, dimension alignment is performed to ensure consistency in vector dimensions, order, and type. After merging, the data is written to the feature storage, which has a versioned structure and supports retrieval by exposure time, item identifier, and version number. To ensure direct alignment between the real-time behavior stream and the offline feature set in subsequent stages, the offline feature set synchronously records the time window identifier and category dimension identifier during writing, forming a routable index key. At this point, the real-time behavior stream carries serialized user behavior information, and the offline feature set carries coded item static attributes and normalized historical indicators. The two can be directly aligned at the time and identifier levels to enter the downstream process.

[0114] This embodiment collects data through a unified entry point and performs event-time-driven window aggregation on clicks, searches, and dwell times. The real-time behavior flow remains ordered within the window and consistent with the exposure context, directly supporting subsequent asynchronous recall and real-time ranking. By performing discrete feature encoding on the set of basic item attributes and numerical normalization on the set of historical item statistics, the offline feature set is unified in terms of dimension, unit, and version, ensuring stable alignment with the real-time behavior flow in terms of time and identifier.

[0115] In one embodiment, step S20 above includes:

[0116] S201, parse the recall channel set and determine the collaborative filtering recall channel, vector recall channel and hotspot recall channel;

[0117] S202, asynchronously trigger the collaborative filtering recall channel, input the real-time behavior stream and offline feature set into the collaborative filtering recall channel, and generate a collaborative filtering item subset;

[0118] S203, asynchronously trigger the vector recall channel, input the real-time behavior stream and offline feature set into the vector recall channel, and generate a vector recall item subset;

[0119] S204, asynchronously trigger the hotspot recall channel, input the real-time behavior stream and offline feature set into the hotspot recall channel, and generate a hotspot item subset;

[0120] S205: Monitor the execution status of each recall channel. If the execution time of a channel exceeds the preset timeout threshold, terminate the incomplete channel.

[0121] S206, Receive the collaborative filtering item subset, vector recall item subset, and hot item subset output from the completed recall channel;

[0122] S207, merge the collaborative filtering item subset, the vector recall item subset, and the hot item subset to obtain the item set;

[0123] S208, Perform a deduplication operation on the item set to generate an initial candidate set.

[0124] In this embodiment, the recall channel set originates from a configurable channel registration list. This list is a structured mapping where the key is the channel name and the values ​​are the channel implementation and runtime parameters. When parsing the recall channel set, the list version is loaded, verifying that the collaborative filtering recall channel, vector recall channel, and hotspot recall channel are all available, and generating a channel runtime context. This runtime context includes input field mappings, query construction rules, connection handles, and references to security credentials. To ensure consistency in subsequent fusion, the item identifier field and source marker field are simultaneously determined during the parsing phase. The source marker field is used as a traceability basis in the merging and deduplication stages.

[0125] When asynchronously triggering a collaborative filtering recall channel, the real-time behavior stream and offline feature set are mapped to a sparse preference vector on the user side and a static attribute fragment on the item side. Adjacency relationship inputs that user similarity or item similarity query dependencies are constructed and submitted to the channel executor in a non-blocking call format. The channel executor accepts the runtime context and input batches, clusters them by user identifier, and performs parallel computation, outputting a collaboratively filtered item subset. Output elements carry item identifiers, channel names, similarity or preference components, timestamps, and request identifiers. The timestamps are used for subsequent monitoring and fusion sorting references, and the request identifiers are used for idempotency control and retry folding.

[0126] When asynchronously triggering a vector recall channel, the behavior sequence in the real-time behavior stream is aligned with the item vector space in the offline feature set to construct a user-side or query-side vector representation. Nearest neighbor retrieval requests are submitted via vector index connection handles. The index can use sharded replicas to support horizontal scaling, a hierarchical structure to reduce memory usage, or compressed representation to improve throughput. Elements in the vector recall item subset carry item identifiers, channel names, vector similarity components, timestamps, and request identifiers. The field layout is consistent with the collaborative filtering item subset for unified processing.

[0127] When the hotspot recall channel is triggered asynchronously, the relevant views of historical statistical indicators of items are read from the offline feature set. Combined with the session context and category preferences in the real-time behavior stream, high-popularity items are selected using the popularity score calculation rules. The popularity score calculation rules are issued by the configuration center and may include time-effect decay, audience weight, and category weight items. The executor selects the corresponding weight according to the user's audience tag and outputs a subset of hotspot items. Each element carries the item identifier, channel name, popularity component, timestamp, and request identifier.

[0128] When monitoring the execution status of each recall channel, an independent tracking identifier and timeout manager are assigned to each parallel request. The timeout manager times the request lifecycle based on a preset timeout threshold. Requests that have not returned by the threshold trigger a termination signal, releasing the connection and computing resources, and recording the timeout event and channel name. The monitoring module continuously collects completion events, failure events, and timeout events, generating channel-level and request-level execution statistics to provide input for subsequent parameter updates and capacity planning. To avoid duplicate triggering due to termination, the monitoring module writes a completion flag in both the completion and termination paths to ensure idempotency.

[0129] When receiving subsets of collaborative filtering items, vector recall items, and hotspot items, the receiver aggregates the output of completed channels according to the requested identifier, filtering out anomalies or duplicates. If a channel is terminated, a termination marker is retained in the aggregation record without generating an item list, ensuring that the fusion logic only processes valid item subsets. After aggregation, a source marker is added to the elements produced by different channels. The value range of the source marker is limited to three enumerated values: collaborative filtering, vector recall, and hotspot.

[0130] When merging subsets of collaboratively filtered items, vector-recalled items, and hotspot items into a single item set, the merger performs the merging based on item identifiers, aggregating identical items from different channels into a single entry, while retaining the source list and each channel component. When a field is missing, it is filled with a default component, and the missing flag is retained. When the same item appears repeatedly in the same channel, only the entry with the latest timestamp is retained. To control the merging scale, the merger can be set with a capacity limit; before reaching the limit, elements that returned earlier are prioritized for inclusion to reduce waiting time.

[0131] When performing deduplication on an item set, the deduplicator uses the item identifier as the primary key to eliminate duplicates and retains the source list and a summary of each channel component. If the same item is hit by multiple channels, the primary source is determined by a combination of source priority and arrival time order, and a secondary source list is recorded. The source priority can be defined via the configuration center; it does not change the existence of an entry, but only affects subsequent interpretation and diagnosis. After deduplication, an initial candidate set is generated. The initial candidate set maintains the consistency of the identifiers and the integrity of the source information at the entry level and is bound to the request identifier of the real-time behavior stream, facilitating direct access during the coarse sorting stage.

[0132] In this embodiment, asynchronous triggering and timeout control free channel execution from the constraints of the slowest channel, reducing waiting time without sacrificing throughput. Multi-channel parallelism introduces three sources: collaborative filtering, vector recall, and hotspot analysis. Merging and deduplication preserve source information and eliminate duplicates, increasing the coverage of the initial candidate set while keeping its size under control. Unified field layout and request identifiers connect the collection, channel execution, and fusion processes. Subsequent coarse sorting can directly consume the initial candidate set to complete rapid filtering, thereby reducing resource consumption and recalculation times, and suppressing overall response latency and invalid calculations.

[0133] In one embodiment, step S30 above includes:

[0134] S301, Set initial cutoff conditions that include a predefined baseline quantity threshold;

[0135] S302, Extract the item basic feature set and the user static feature set from the initial candidate set;

[0136] S303, input the set of basic features of the items and the set of static features of the users into the lightweight ranking model, and determine the initial screening score of each item through the lightweight ranking model;

[0137] S304, Sort the items in the initial candidate set in descending order according to the initial screening score to obtain a sorted item sequence;

[0138] S305, obtain real-time system load metrics;

[0139] S306, Adjust the baseline number threshold of the initial truncation condition according to the real-time load index of the system, and generate the updated truncation condition;

[0140] S307, Select the set of items with the highest sorting order from the sorted item sequence according to the updated truncation condition;

[0141] S308, Generate a coarse-ranked candidate set containing the set of items ranked first.

[0142] In this embodiment, the initial candidate set comes from the preceding recall and fusion stage. Entries are identified by their item identifier as the primary key, along with a source tag, timestamp, and a snapshot of basic attributes. To reduce the candidate size within a limited timeframe and make way for the deep sorting stage, an initial truncation condition including a baseline quantity threshold is established. This baseline quantity threshold is derived from a configuration center or experience statistics library, and is generated by binding it to business scenarios, customer segmentation, and edge-side characteristics, forming a traceable version tag for easy subsequent dynamic adjustment and canary-scale verification. The initial truncation condition is maintained in both local memory and a distributed cache. Read paths prioritize local access to reduce remote access overhead; if a cache hit fails, the process falls back to distributed storage.

[0143] Two types of input features are extracted from the initial candidate set. The basic item feature set consists of discrete attributes such as category, brand, display location, content genre, and producer tags, derived from static dimension tables in the offline feature library or real-time snapshots. During synchronization, the field mapping is ensured to be consistent with the dictionary version. The user static feature set includes fields such as region, device type, long-term preference tags, membership level, and risk stratification, derived from the user profile library or real-time session context. The extraction process performs field selection, missing value imputation, and dictionary mapping validation. A sparse index and mask bitmap are prepared for subsequent model computation to prevent invalid dimensions from entering the computation graph.

[0144] The lightweight ranking model takes two sets as input and outputs an initial screening score for each item. The model structure is not limited to a single type; it can employ a linear scoring structure for interpretability, a small tree model to enhance nonlinear fitting capabilities, or a shallow neural network to balance expressive power and computational efficiency. The input encoding layer assigns sparse indexes or hash buckets to discrete attributes, and numerical fields undergo scale normalization to align dimensions. The inference phase uses vectorized batch processing and thread pool concurrency, while the computation graph uses a fixed memory pool and a warm-up mechanism to reduce initial latency. The output is an initial screening score that corresponds one-to-one with the item identifier, along with a batch identifier and timestamp to support monitoring and verification.

[0145] The initial candidate set is sorted in descending order based on the initial screening scores to obtain a sorted item sequence. The sorting process uses a stable sorting method to ensure that the relative order of items with the same score can be reproduced. When the data size exceeds the single machine memory, external sorting and block merging are enabled, and the block size is matched with the disk sequential read and write characteristics. The sorting results are exposed to downstream devices in the form of a read-only view to avoid copy overhead. At the same time, statistical information, including score quantiles, long tail proportion, and source distribution, is attached to the view for subsequent threshold scheduling.

[0146] The system's real-time load metrics are provided by a multi-dimensional monitoring pipeline, including queue length of the online inference cluster, CPU and memory usage, network round-trip latency, single-request latency distribution, and capacity health of the local node and nodes in the same data center. Metric sampling uses sliding window aggregation to output stable estimates, and abnormal spikes are suppressed using robust filtering. To make scheduling more sensitive to business fluctuations, load metrics can also incorporate endpoint throttling signals and page interactivity time measurements, forming a unified cross-device stress view.

[0147] Based on the aforementioned load metrics, the baseline threshold in the initial truncation conditions is dynamically adjusted to generate updated truncation conditions. The adjustment strategy uses the upper and lower thresholds to form a safety boundary and overlays multiple adjustment factors, such as real-time traffic levels, session depth, user segmentation, hotspot intensity, and regional time zone differences. Piecewise linear mapping can be used to ensure monotonic response, proportional control and integral compensation can be used to smooth fluctuations, and different gain factors can be configured for different user groups to achieve differentiated computing power allocation. The updated truncation conditions include version information and an effective timestamp, facilitating gray-scale comparison and playback analysis.

[0148] Based on the updated truncation criteria, the top-ranked item set is directly extracted from the sorted item sequence. The extraction operation is performed on a read-only view, returning a lightweight indexed array instead of a deep copy of the set to reduce memory usage. If there are rule-conflicting entries at the beginning of the sequence, such as risk-masking or compliance-masking, they are removed in place and replaced sequentially without compromising stability. If there is a risk of insufficient coverage of less popular categories affecting subsequent diversity strategies, similarly scored replacements and source complementarity can be performed while maintaining the same quantity threshold. After extraction, a coarse-ranked candidate set containing the top-ranked item set is generated, retaining the score range and source distribution summary to support the next stage of deep sorting and offline review.

[0149] This embodiment introduces load-aware dynamic adjustment starting from the initial truncation condition, allowing the quantity threshold to change synchronously with computing power and traffic status. Under low load, more high-scoring entries are retained to improve upstream coverage, while under high load, the truncation is tightened to control downstream inference pressure. The lightweight ranking model provides stable initial screening scores within a strictly limited computational budget. Combined with stable ranking and read-only views, it achieves a low-overhead transformation from the initial candidate set to the coarse-ranked candidate set. This process significantly reduces invalid computation, compresses the input size and variance of the deep ranking stage, reduces end-to-end latency, and retains observability of source distribution and score quantiles, facilitating continuous optimization through subsequent closed-loop updates.

[0150] In one embodiment, step S40 above includes:

[0151] S401, Divide the real-time behavior stream into time windows and extract the user behavior sequence within each time window;

[0152] S402, converts the user behavior sequence of each time window into a real-time feature vector, and generates a real-time feature vector sequence;

[0153] S403, Extract the historical feature vector corresponding to the time window from the offline feature set;

[0154] S404, Perform a time dimension alignment operation on the real-time feature vector sequence and the historical feature vector to generate a time-aligned feature set;

[0155] S405, Perform a standardization and dimensionality reduction operation on the time-aligned feature set to generate a dimension-aligned feature set;

[0156] S406, Extract the inherent properties of the product from the offline feature set as static features;

[0157] S407, the dimension alignment feature set is concatenated with the static feature to obtain the alignment feature set.

[0158] In this embodiment, when dividing the real-time behavior stream into time windows, a unified time base and session identifier are first bound to each behavior event. The window length and sliding step size are then set based on the continuous active interval, page interactivity time, and device heartbeat signal, generating adjacent and overlapping discrete windows. Within each window, events are stably sorted according to their time keys, and user and device identifiers are used as grouping keys to obtain the user behavior sequence within the window. To suppress abnormal spikes, window aggregation simultaneously calculates event denoising weights and repeated click suppression coefficients to ensure that the behavior sequence reflects the current intent rather than noise.

[0159] When converting user behavior sequences across time windows into real-time feature vectors, events such as clicks, dwell times, searches, and add-to-cart actions are mapped to sparse discrete spaces and compact numerical spaces for parallel encoding. Discrete fields are indexed using dictionary mapping or hash mapping, while numerical fields undergo scale alignment and distribution truncation. Sequence-specific order relationships are expressed through positional encoding, time interval embedding, or decay coefficient embedding. To avoid insufficient information in short sequences, in-window aggregation statistics (duplicate count, deduplication ratio, mean dwell time, most recent time difference, etc.) are introduced and concatenated into the single-window vector. In multi-window scenarios, weights are assigned according to window freshness and weighted summaries are performed to obtain a real-time feature vector sequence, ensuring coverage of short-term interests without excessive forgetting of recent signals.

[0160] When extracting historical feature vectors corresponding to time windows from the offline feature set, the historical statistics and profile slices for the same user and the same item are retrieved using the start and end times of the window as query conditions. The user side includes long-term preference tags, category preference distribution, and stable attribute stratification; the item side includes category, brand, content genre, author or merchant tags, and structured attributes; the interaction side includes cross-window conversion rate, cross-day exposure frequency, and biased CTR correction items. During extraction, version numbers and feature dictionaries are strictly matched to ensure consistency between offline feature slices and window time. If historical slices are missing, interpolation between adjacent time slices or regression to the global steady-state slice is used, and regression markers are recorded for subsequent monitoring and training sample filtering.

[0161] When aligning real-time feature vector sequences with historical feature vectors in terms of time dimension, a key-value alignment relationship is first established between the two types of vectors using window timestamps. Then, signals with different time granularities are reduced to the same reference time point using a freshness decay function, a time difference gating function, and a cross-window smoothing function, forming a time-aligned feature set. Periodic terms at daily and weekly boundaries are aligned using cosine phase expansion. Non-stationary periods such as holidays are suppressed for abnormal drift using binary indicators and Laplace smoothing. The aligned output retains three types of metadata: time alignment weights, backtracking flags, and alignment residuals, for downstream interpretability and online playback.

[0162] When performing standardized dimensionality reduction on the time-aligned feature set, numerical standardization and robust scaling are first performed at both intra-batch and inter-batch scales to unify the value ranges from different sources and with different dimensions. Then, redundant dimensions are screened out using statistical correlation, mutual information, and redundancy assessments. Finally, compressed representations are generated through principal component projection, stochastic feature mapping, or a lightweight encoder to obtain the dimension-aligned feature set. To ensure online stability, the dimensionality reduction matrix or encoder parameters employ a dual-track update strategy of offline prediction and online distillation, with version labels and checksums to ensure consistency between online inference and offline training.

[0163] When extracting inherent product attributes as static features from offline feature sets, only time-independent or slowly changing structured attributes are retained, such as category hierarchy, brand hierarchy, production region, author or merchant identity tags, content medium format, and display style tags. Static features undergo dictionary freezing and consistency verification before publication. Online, only the frozen sparse index and necessary numerical embeddings are read to avoid drift caused by time.

[0164] When concatenating the dimension-aligned feature set with static features, the compressed time-varying representation and sparse static index are merged at the vector level according to predefined field order and type alignment rules, outputting the aligned feature set. The merging process preserves field masks, missing bits, and source labels. Sequence fields are folded into fixed-length representations according to pooling strategies (mean pooling, attention pooling, or most recent pooling) to ensure that downstream ranking and recall modules can directly consume them. The final output is exposed as a zero-copy view to reduce memory usage, and carries time-aligned weights and static label indices under the same entry for easy sharing between different models.

[0165] This embodiment transforms real-time behavior streams into representations with sequential relationships and freshness indicators by constructing time windows and sequence encoding. Through temporal alignment and standardized dimensionality reduction, the real-time representation and offline slices achieve consistency in temporal reference and feature space. Static attribute concatenation ensures that the inherent semantics of items remain stable and visible in subsequent sorting stages. The overall output aligned feature set achieves temporal unification, spatial unification, and semantic completion within a single query, reducing the additional overhead caused by distribution drift and feature loss in downstream models, improving online inference stability, and providing an interpretable, replayable, and versionable input base for subsequent fine-tuning and exploration stages.

[0166] In one embodiment, step S50 above includes:

[0167] S501, Extract the set of dynamic feature vectors of items from the coarse candidate set;

[0168] S502, the alignment feature set is divided into a user feature group and a context feature group;

[0169] S503, the set of dynamic feature vectors of the items, the user feature group and the context feature group are input into the attention neural network in the deep ranking model, and the item interaction weight matrix is ​​generated through the attention neural network.

[0170] S504, The deep ranking model performs a weighted fusion operation on the dynamic feature vector set of items based on the item interaction weight matrix to generate a finely ranked feature vector set;

[0171] S505, Input the set of fine-ranking feature vectors into the fully connected layer of the deep ranking model to determine the fine-ranking score of each item;

[0172] S506, Sort the items in the coarse-ranked candidate set in descending order according to the fine-ranking score;

[0173] S507, Based on the preset fine ranking quantity threshold, select the top subset of items from the items sorted in descending order to generate a fine ranking candidate set.

[0174] In this embodiment, the coarse-ranked candidate set is used to carry item entries that need to enter the deep ranking. First, a set of dynamic feature vectors is extracted for each item. The dynamic features are derived from recent interactions and time-varying profiles, including recent window exposure and click counts, recent window conversion statistics, recent interaction time intervals, short-term fluctuations in price or content popularity, and cross-session freshness weights. Discrete fields are indexed and entered into a sparse embedding table, while continuous fields are robustly scaled and truncated to maintain their numerical form. These are then concatenated with local summaries of the item's static attributes to form an item-level dynamic representation. To reduce online read overhead, a two-level cache is provided: a local item cache carries popularity, recent counts, and freshness, while an intra-batch cache carries the embedding vectors of duplicate items. If a match is found, the vectors are reused directly; otherwise, the calculation is performed back to the source.

[0175] Before being fed into the model, the aligned feature set is divided into a user feature group and a context feature group. The user feature group focuses on stable and semi-stable signals on the user side, including interest preference distribution, long-term activity, price sensitivity stratification, category or theme preference vectors, etc. The context feature group focuses on the current retrieval and display environment, including time segmentation, geographic location granularity, terminal and network profiles, scene and entry point tags, traffic strategy on / off bits, etc. Both groups of vectors maintain their respective field order, mask bits, and source tags. Missing bits are expressed by a zero vector and explicit missing markers to avoid implicit information leakage. After the division, normalized statistics are generated for both groups of vectors and version identifiers are added to ensure consistency across batches.

[0176] The set of dynamic feature vectors for items, the user feature set, and the context feature set are fed into the attention neural network in the deep ranking model. The user feature set, after linear transformation, serves as the query; the key-value pairs mapped from the set of dynamic feature vectors for items are used to construct the attention input; and the context feature set serves as the gating and bias, contributing to the offset and scaling terms of the attention score. The attention layer employs a multi-head structure, with each head independently generating an item-level attention distribution. A masking mechanism assigns minimal scores to fields with missing or invalid combinations, a temperature parameter controls the sharpness of the distribution, and layer normalization and residual connections ensure numerical stability. The outputs of each head are concatenated along the feature dimension and projected to obtain the item interaction weight matrix. Rows correspond to items, and columns correspond to either the user interest subspace or the context modulation subspace. Matrix elements represent the relevance strength of the corresponding item under a given interest and context.

[0177] Based on the item interaction weight matrix, a weighted fusion of the item dynamic feature vector set is performed to produce a refined feature vector set. Specifically, row vectors are used as weights to linearly weight the multi-granularity dynamic sub-vectors of each item, and then gating terms modulated by the user and context are superimposed. Residual paths are also introduced to ensure that the fused vectors retain the identifiable information expressed by the original items while incorporating customized offsets from the user and the scene. Layer normalization and lightweight regularization at the feature level are added during the fusion stage to prevent a single subspace from dominating and to suppress extreme weights.

[0178] The refined feature vector set is fed into the fully connected layer at the tail of the model to calculate the refined score. The tail network adopts a multilayer perceptron structure, using nonlinear activation and batch normalization between layers, with the last layer outputting a single-value score. To unify the dimensions and calibration errors of multi-source inputs, group calibration is used during the training phase to align the output distribution of different scenarios, and calibration lookup tables are retained during the inference phase; the score channel retains the version number and time stamp for easy log playback and A / B switching. For entries with the same score, a deterministic parallel sorting stability rule is adopted, and the order is determined by a stability key (e.g., a combination of entry identifier hash and publication time) to avoid list jitter.

[0179] After sorting the items in the coarse-ranked candidate set in descending order based on their fine-ranking scores, a subset of the top-ranked items is selected from the sorted results according to a preset fine-ranking quantity threshold to generate a fine-ranking candidate set. The quantity threshold is derived from online configuration or a policy service, supporting deployment by entry point, scenario, and device dimensions. It also retains dual-threshold protection with a minimum guaranteed quantity and a maximum upper limit to prevent empty sets or overload under extreme load or extremely sparse traffic. Threshold execution follows a "maximum first, guaranteed quantity second" order. If the number of valid items with scores is insufficient to meet the guaranteed quantity, a score-based fallback strategy is triggered, supplementing the candidate items and marking them with a fallback flag for subsequent exploration or re-ranking. The generated fine-ranking candidate set establishes a one-to-one mapping with the upstream input, and includes the score, source, modulation weight, and fallback flag for downstream injection and final generation.

[0180] This embodiment completes item-level dynamic representation extraction, user and context grouping modeling, attention-based interaction weight calculation and weighted fusion within the same inference chain, and then uses the calibrated scores to stably descend the order and determines the output size with a quantity threshold to form a structured fine-ranking candidate set. This process explicitly aligns and controllably fuses user interests, scene conditions, and item dynamic signals in the vector space, reducing the secondary processing burden of misaligned features in downstream stages; attention weights and backoff markers provide traceability, facilitating stable ranking during load fluctuations and scene switching; thresholding ensures that the output size matches the computing resources, providing a high-confidence, low-jitter input set for subsequent exploration injection and final list generation.

[0181] In one embodiment, step S60 above includes:

[0182] S601, Obtain the exposure frequency data of each item in the item library and generate the item popularity distribution;

[0183] S602, retrieve the current user's unexposed item records;

[0184] S603, Based on the heat distribution of the items and the record of unexposed items, determine the exploration confidence score for each item;

[0185] S604, Select a preset number of items to explore based on the exploration confidence score, and generate an exploration candidate set;

[0186] S605, merge the exploration candidate set and the refined candidate set to generate a merged item set;

[0187] S606, Perform a deduplication operation on the merged item set to generate an exploration mixed set;

[0188] S607, extract the output score of each item from the exploration mix set, wherein the output score is the ranking score of the ranking candidate item or the exploration confidence score of the exploration candidate item;

[0189] S608, Sort the items in the exploration mix in descending order according to the output score;

[0190] S609, Select the first output item subset from the items sorted in descending order according to the preset final output quantity threshold;

[0191] S610, Generate a final output set that includes the subset of the first output items.

[0192] In this embodiment, the exploration channel first reads the historical exposure counts and timestamp sequences of the item database, and calculates the item popularity distribution based on a sliding time window and time decay weights. The time window is used to limit the observation period for statistical purposes, and time decay is used to reduce the impact of early exposures on the current popularity. To avoid bias caused by extreme bursts, the exposure counts within a single window can be truncated and logarithmically scaled to obtain a stable popularity distribution vector. The popularity distribution is stored in a read-only cache with the item identifier as the key and the normalized popularity value as the value, along with a generated timestamp, to ensure consistency in subsequent calculations.

[0193] The user-side service extracts records of unexposed items in parallel. These records are derived from the difference between recent display logs and click logs, excluding items already displayed or interacted with within the current window, and can be supplemented with negative filtering conditions (e.g., categories explicitly blocked by the user). The records of unexposed items are distributed to the exploration channel in the form of a set or Bloom filter to ensure rapid member determination in high-concurrency scenarios.

[0194] The confidence score is calculated item-by-item across the entire item dimension. Two types of signals are introduced during the calculation: one from item popularity distribution, reflecting acceptability at the group level; and the other from the matching degree between unexposed item records and user profiles (e.g., similarity to user preferred topics, semantic proximity to recent query intent, and matching degree with price range or content duration). These two types of signals are fused into the confidence score using a learnable or configurable weighting method, with independent weight configuration versions set for different entry points and terminal scenarios. To avoid excessive concentration on top-ranked items, a diversity penalty can be added to the confidence score calculation, such as allocating coverage rewards based on item attribute clusters or topic clusters, thereby increasing the probability of long-tail items being selected.

[0195] The preset exploration quantity is issued by the strategy service and configured separately for entry point, scene, and device type, including two constraints: a minimum guaranteed quantity and a maximum upper limit quantity. The exploration channel is traversed in descending order according to the exploration confidence score, selecting items that meet the constraints of unexposed item records and diversity constraints in turn, until the preset exploration quantity or the upper limit quantity is reached. If there are not enough candidates, a rollback mechanism can be triggered to relax the diversity constraints or expand the time window with a lower weight to supplement the exploration candidate set, and the supplemented items are marked with a rollback mark for reference in the subsequent sorting stage.

[0196] The candidate set for exploration and the candidate set for refinement are merged at the item identifier dimension to form a merged item set. During merging, source tags (refinement source or exploration source), source scores (refinement score or exploration confidence score), time tags, and rollback markers are retained as the basis for subsequent sorting and auditing. To avoid duplicate entries entering subsequent processes, a deduplication operation is performed on the merged item set. The deduplication strategy adopts a deterministic retention rule: only a single entry with the same item identifier is retained; if there is a source conflict, the refinement source is prioritized, and the entry is marked with "includes exploration backup" to facilitate subsequent analysis of the benefits of multi-source fusion.

[0197] After establishing the hybrid ensemble, comparable output scores need to be generated for each entry. Entries from the refined ranking candidate set directly use the refined ranking scores; entries from the exploratory candidate set directly use the exploratory confidence scores. To achieve global comparability, a lightweight calibration module can be mounted in the online service to apply grouped calibration parameters for different source channels, mapping scores to a unified dimension and distribution range while retaining group identifiers for easy channel-specific evaluation. Calibration parameters are updated on a rolling basis according to scenario and time, and consistency between online and offline processes is ensured through version numbers and timestamps.

[0198] The system explores a stable descending sorting of hybrid sets based on output scores. To handle tied scores and minor numerical fluctuations, a stable sorting key is introduced, typically composed of an item identifier hash and a publication or listing time. This provides a deterministic order when scores are identical, reducing front-end list jitter. After sorting, a subset of output items is selected based on a preset final output quantity threshold. This threshold is also issued by a strategy service according to the scenario, following a dual-threshold logic of maximum upper limit and minimum lower limit: first, the upper limit is used for truncation; if the number of valid items is lower than the lower limit, the remaining items are supplemented according to diversity priority, and a supplementation mark is retained. The subset of output items, along with output scores, source tags, rollback markers, and diversity cluster information, is packaged together to generate the final output set. The configuration version, time tag, and stable sorting key are also recorded for subsequent feedback collection and offline review.

[0199] Example Explanation: In the fintech business, this can be applied to robo-advisory scenarios. The system first collects user activity data from multiple sources on the wealth management platform, such as clicking on fund details pages, searching for high-yield bonds, and browsing insurance product comparison pages. This data is then combined with the basic attributes, historical return volatility, and risk ratings of each type of financial product in the product database to form a real-time behavior stream and an offline feature set. The real-time behavior stream depicts the user's current focus, while the offline feature set provides stable dimensions such as asset class, risk level, and historical return rate.

[0200] During the recall phase, the system asynchronously triggers collaborative filtering recall, vector recall, and hot topic recall through a set of recall channels. The collaborative filtering channel generates a subset of fund or insurance products based on the historical investments of user groups with similar interests to the current user; the vector recall channel filters candidates based on the similarity between the user's recent search keywords and browsing behavior and the semantic vector space of financial products; the hot topic recall channel tracks frequently purchased popular funds or short-term deposit products across the platform in real time, forming a hot topic subset. Each channel executes independently and in parallel. If the execution time exceeds a threshold, the timeout channel will terminate. Finally, the effective subsets are merged and deduplicated to obtain the initial candidate set.

[0201] In the coarse sorting stage, the system extracts basic product features and static user features from the initial candidate set, such as the user's risk preference level, past investment period preference, and product yield fluctuation range, and inputs them into a lightweight sorting model to calculate the initial screening score. After the products are sorted in descending order of score, the system also adjusts the cutoff condition based on the platform's real-time load, reducing the candidate number threshold during peak hours and expanding the screening range during low load, thereby generating a coarsely sorted candidate set.

[0202] The real-time behavior stream is then transformed into a real-time feature set, such as a user's frequent clicks on fixed-income products within the past hour. This feature set is combined with historical return data and risk coefficients from the offline feature set, and after time-dimensional alignment and standardization dimensionality reduction, it is finally concatenated with static features to generate an aligned feature set. This set maintains consistency with user behavior over time, ensuring that subsequent ranking reflects the user's immediate needs.

[0203] The coarse-ranked candidate set and the aligned feature set are input into the deep ranking model. The attention neural network in this model calculates the interaction weights between product features, user behavior features, and contextual features. For example, short-term user interest in money market funds is strengthened in the weight matrix, while long-term interest in equity funds is weakened. A weighted fusion is used to obtain the refined ranking feature vector set, and a refined ranking score for each product is output through a fully connected layer. The system sorts the products in descending order based on their refined ranking scores and selects the top subset of products within a preset threshold to form the refined ranking candidate set.

[0204] To avoid the results being biased towards recommending only high-frequency products, the system injects an exploration candidate set into the refined ranking candidate set through an exploration channel. The exploration candidate set is generated based on the popularity distribution of products in the item library and the user's unexplored history. For example, items that a user has never viewed green financial bonds or innovative insurance products will be assigned a higher exploration confidence score. The exploration candidate set and the refined ranking candidate set are merged and deduplicated to form a hybrid exploration set. Each product is assigned an output score; refined ranking products retain their original ranking scores, while exploration products use their exploration confidence scores. The hybrid set is sorted in descending order of output scores, and the top subset within the final output quantity threshold is selected to form the final output set. This set includes both highly relevant products and potential points of interest for the user, achieving a balance between relevance and diversity.

[0205] During the feedback phase, the system continuously collects feedback data from the final output set. Events such as a user clicking on a fund's details page, skipping an insurance product, or expressing disinterest in a bond are analyzed as positive feedback items, negative feedback items, and skip frequency signals. Negative feedback data reduces the trigger weight of the corresponding recall channel, and skip frequency adjusts the cutoff condition for coarse ranking. Both positive and negative feedback data are used for incremental training of the deep ranking model to update weights. The predictive contribution of each dimension in the aligned feature set is statistically analyzed and used to adjust the feature weight allocation strategy. In this way, the recommendation system can maintain continuous optimization capabilities in an environment of rapid iteration of financial products and changing user interests.

[0206] In the healthcare sector, this can be applied to personal health management platforms. The platform first collects multi-source user behavioral data and health-related item information. Multi-source behavioral data includes user behavior logs such as clicking on nutrition plan details, searching for sleep improvement training, and browsing psychological adjustment videos within health management applications. This data is processed into a real-time behavioral stream. The item database stores basic attributes and historical statistics of health-related products and services, such as the duration and energy consumption of exercise courses, the ingredients and user distribution of nutritional supplements, and the number of times psychological counseling audio was listened to and the average viewing time. These are encoded and normalized to generate an offline feature set. The real-time behavioral stream reflects the user's immediate health interests, while the offline feature set provides stable attributes of health resources. The combination of these two provides the input basis for subsequent recommendations.

[0207] During the recall phase, the system asynchronously triggers different types of recall operations based on the recall channel set. The collaborative filtering channel retrieves candidate items such as exercise programs and nutritional supplements based on the historical selections of users with similar interests; the vector recall channel uses keyword matching between user searches and the semantic vector representation of resources to filter health management-related content; and the hot topic recall channel retrieves health content that has been frequently used recently and has received positive feedback, such as newly released exercise videos or widely popular nutritional combinations. All channels execute in parallel; if a timeout occurs, the unfinished channel is terminated. Finally, the results of collaborative filtering, vector recall, and hot topic recall are merged and deduplicated to form the initial candidate set.

[0208] The initial candidate set then enters the coarse sorting stage. The system extracts basic attributes of the candidate content, such as exercise duration and nutrient density, and combines this with the user's static health profile information, such as age group, past exercise habits, and dietary structure, inputting this data into a lightweight sorting model to calculate an initial screening score. The candidate content is then sorted in descending order based on the initial screening score, and the truncation condition is adjusted according to the system's real-time load. This reduces the number of candidates when the system is busy and retains more content when the load is low, ultimately generating a coarsely ranked candidate set.

[0209] The platform further processes real-time behavior streams to generate real-time feature sets. For example, if a user frequently searches for sleep aids or clicks on low-salt diet courses within the past week, these are converted into a sequence of real-time feature vectors. Combined with historical health data corresponding to the time window in the offline feature set, a time-consistent feature set is formed through time-dimensional alignment and standardized dimensionality reduction. This set is then concatenated with the static attributes of the health content to obtain an aligned feature set, providing multi-dimensional input for personalized recommendations.

[0210] The coarse-ranked candidate set and the aligned feature set are then fed into a deep ranking model. An attention neural network learns the interaction weights between a user's immediate needs and candidate health resources; for example, a user who has recently focused on sleep quality will have their behavioral characteristics weighted towards sleep-related courses. The weighted fusion-generated fine-ranking feature vector is passed through a fully connected layer to output a fine-ranking score for each item. The system sorts these scores in descending order and selects the top-ranked items within a specified threshold to generate the fine-ranking candidate set.

[0211] To enhance recommendation diversity and alleviate the information cocoon problem in health management, the platform injects an exploration candidate set through an exploration channel. This candidate set is generated based on the popularity distribution of health content in the item library and resources the user hasn't yet encountered. For example, content a user hasn't tried, such as psychological adjustment audio or new home fitness programs, is assigned an exploration confidence score. The exploration candidate set is merged with the refined candidate set to remove duplicates, generating a hybrid exploration set. Each item is assigned an output score; refined content retains its refined score, while exploration content uses an exploration confidence score. The hybrid set is sorted in descending order of output scores, and the system selects the top subset based on a quantity threshold to generate the final output set. This set not only meets the user's immediate health needs but also expands into previously unexplored areas.

[0212] The system collects feedback data from the final output set, including user behaviors such as clicking on a sports video, skipping a nutrition plan, and marking uninteresting psychological training. This feedback is analyzed to generate positive feedback items, negative feedback items, and skip frequency data. Negative feedback items are used to reduce the trigger weight of the corresponding resource category in the recall channel, and skip frequencies are used to adjust the cutoff conditions in the coarse ranking stage. Both positive and negative feedback items are used together to update weights during incremental training of the deep ranking model. Simultaneously, the contribution of each dimension in the aligned feature set is statistically analyzed, the weights of inefficient features are weakened, and the weights of efficient features are strengthened, thereby dynamically optimizing the feature generation strategy.

[0213] During this process, the recommendation system can continuously adapt to changes in the user's health goals. For example, when a user recently clicks on more content related to mental health, the model gradually increases the weight of content related to mental health adjustment; when a user neglects certain diet courses for a long time, the corresponding content is gradually weakened in recall and ranking. This real-time feedback mechanism ensures that the recommendation process always closely follows the user's health needs, achieving a dynamic balance across multiple dimensions such as exercise, nutrition, and mental health.

[0214] This embodiment introduces explicit heat distribution and unexposed item records to form a calculable exploration confidence score, which is then merged and sorted with the fine-ranking score under a unified dimension. This allows the exploration channel to supplement novel items without sacrificing relevance. Through merging, deduplication, stable sorting, and double-threshold truncation, the determinism and scalability of the hybrid list are ensured. The preset exploration quantity and final output quantity thresholds are issued by the strategy service according to different scenarios and are combined with rollback and diversity constraints to improve long-tail coverage and the exposure opportunities of new items, while suppressing latency and resource waste. The generated final output set maintains traceability, low jitter, and easy evaluation characteristics in multiple scenarios.

[0215] In one embodiment, a cascaded real-time feedback fusion output device is provided, which corresponds one-to-one with the cascaded real-time feedback fusion output method described in the above embodiments. (Refer to...) Figure 3 , Figure 3This is a schematic diagram of the functional modules of a preferred embodiment of the cascaded real-time feedback fusion output device of the present invention. The modules include a data acquisition module 10, a recall module 20, a coarse sorting module 30, a feature alignment module 40, a fine sorting module 50, an exploration injection module 60, and a feedback optimization module 70. Detailed descriptions of each functional module are as follows:

[0216] Data acquisition module 10 is used to collect multi-source behavioral data and item information to generate real-time behavioral streams and offline feature sets;

[0217] The recall module 20 is used to asynchronously trigger a recall operation based on the recall channel set, perform recall on the real-time behavior stream and offline feature set, and fuse the recall results to generate an initial candidate set.

[0218] The coarse sorting module 30 is used to perform coarse sorting on the initial candidate set and to filter and generate a coarsely sorted candidate set from the initial candidate set according to the truncation condition.

[0219] The feature alignment module 40 is used to process the real-time behavior stream to generate a real-time feature set, and align the real-time feature set with the offline feature set to obtain an aligned feature set.

[0220] The fine ranking module 50 is used to input the coarse ranking candidate set and the alignment feature set into the deep ranking model, and generate a fine ranking candidate set through the deep ranking model.

[0221] The exploration injection module 60 is used to inject the exploration candidate set into the fine ranking candidate set through the exploration channel, generate the exploration mixture set, and generate the final output set based on the exploration mixture set;

[0222] The feedback optimization module 70 is used to collect the feedback data set of the final output set, and update the parameters of the recall channel set, the truncation condition of the coarse ranking, the weight of the deep ranking model, and the generation strategy of the alignment feature set according to the feedback data set.

[0223] In one embodiment, the data acquisition module 10 is specifically used for:

[0224] Collect click event streams, search event streams, and page dwell event streams from user interaction logs;

[0225] The click event stream, search event stream, and page dwell event stream are aggregated by time windows to generate a real-time behavior stream;

[0226] Extract the set of basic attributes and the set of historical statistical indicators of items from the item database;

[0227] Perform discrete feature encoding on the set of basic attributes of the item to generate a set of static feature vectors for the item;

[0228] Perform numerical normalization on the set of historical statistical indicators of the items to generate a set of dynamic feature vectors for the items;

[0229] The set of static feature vectors and the set of dynamic feature vectors of the items are merged to form an offline feature set.

[0230] In one embodiment, the recall module 20 is specifically used for:

[0231] Analyze the recall channel set to determine the collaborative filtering recall channel, vector recall channel, and hotspot recall channel;

[0232] The collaborative filtering recall channel is triggered asynchronously, and the real-time behavior stream and offline feature set are input into the collaborative filtering recall channel to generate a collaborative filtering item subset.

[0233] The vector recall channel is asynchronously triggered, and the real-time behavior stream and offline feature set are input into the vector recall channel to generate a vector recall item subset.

[0234] The hotspot recall channel is triggered asynchronously, and the real-time behavior stream and offline feature set are input into the hotspot recall channel to generate a subset of hotspot items;

[0235] Monitor the execution status of each recall channel, and terminate the incomplete channel if the execution time of the channel exceeds the preset timeout threshold;

[0236] Receive the collaborative filtering item subset, vector-recalled item subset, and hot item subset output from the completed recall channel;

[0237] Merge the collaborative filtering item subset, the vector recall item subset, and the hot item subset to obtain the item set;

[0238] Perform a deduplication operation on the set of items to generate an initial candidate set.

[0239] In one embodiment, the coarse sorting module 30 is specifically used for:

[0240] Set initial cutoff conditions that include a predefined baseline quantity threshold;

[0241] Extract the basic feature set of items and the static feature set of users from the initial candidate set;

[0242] The set of basic features of the items and the set of static features of the users are input into the lightweight ranking model, and the initial screening score of each item is determined by the lightweight ranking model.

[0243] The items in the initial candidate set are sorted in descending order according to the initial screening scores to obtain a sorted item sequence.

[0244] Obtain real-time system load metrics;

[0245] The baseline number threshold of the initial truncation condition is adjusted based on the real-time load index of the system to generate the updated truncation condition;

[0246] Based on the updated truncation condition, select the set of items that rank first from the sorted item sequence;

[0247] Generate a coarse-ranked candidate set containing the set of items ranked first.

[0248] In one embodiment, the feature alignment module 40 is specifically used for:

[0249] The real-time behavior stream is divided into time windows, and the user behavior sequence within each time window is extracted;

[0250] Transform the user behavior sequence of each time window into a real-time feature vector to generate a real-time feature vector sequence;

[0251] Extract the historical feature vector corresponding to the time window from the offline feature set;

[0252] Perform a time dimension alignment operation on the real-time feature vector sequence and the historical feature vector to generate a time-aligned feature set;

[0253] Perform a standardization and dimensionality reduction operation on the time-aligned feature set to generate a dimension-aligned feature set;

[0254] Extract the inherent properties of the product from the offline feature set as static features;

[0255] The alignment feature set is concatenated with the static feature to obtain the alignment feature set.

[0256] In one embodiment, the fine sorting module 50 is specifically used for:

[0257] Extract the set of dynamic feature vectors of items from the coarse candidate set;

[0258] The alignment feature set is divided into a user feature group and a context feature group;

[0259] The set of dynamic feature vectors of the items, the user feature group, and the context feature group are input into the attention neural network in the deep ranking model, and the item interaction weight matrix is ​​generated by the attention neural network.

[0260] The deep ranking model performs a weighted fusion operation on the dynamic feature vector set of items based on the item interaction weight matrix to generate a finely ranked feature vector set.

[0261] The set of fine-ranking feature vectors is input into the fully connected layer of the deep ranking model to determine the fine-ranking score of each item;

[0262] The items in the coarse-ranked candidate set are sorted in descending order according to the fine-ranking score;

[0263] Based on a preset fine-ranking threshold, a subset of items is selected from the items sorted in descending order to generate a fine-ranking candidate set.

[0264] In one embodiment, the exploration injection module 60 is specifically used for:

[0265] Obtain the exposure frequency data of each item in the item library and generate the item popularity distribution;

[0266] Retrieve the current user's unexposed item records;

[0267] Based on the heat distribution of the items and the record of unexposed items, determine the exploration confidence score for each item;

[0268] Based on the exploration confidence score, a preset number of items are selected for exploration to generate an exploration candidate set;

[0269] The exploration candidate set and the refined candidate set are merged to generate a merged item set;

[0270] Perform a deduplication operation on the merged item set to generate an exploration mix set;

[0271] The output score for each item is extracted from the exploration mix set. The output score is either the ranking score of the ranking candidate item or the exploration confidence score of the exploration candidate item.

[0272] Sort the items in the exploration mix in descending order based on the output scores;

[0273] Based on the preset final output quantity threshold, select the first output item subset from the items sorted in descending order;

[0274] Generate a final output set that includes the subset of the first output items.

[0275] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be as follows: Figure 4As shown, the computer device includes a processor, memory, network interface, and database connected via a system bus. The processor provides determination and control capabilities. The memory includes non-volatile and / or volatile storage media and internal memory. The non-volatile storage media stores the operating system, computer programs, and database. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used to communicate with external clients via a network connection. When the computer program is executed by the processor, it implements the functions or steps of a cascaded real-time feedback fusion output method on the server side.

[0276] In one embodiment, a computer device is provided, which may be a client, and its internal structure diagram may be as follows: Figure 5 As shown, the computer device includes a processor, memory, network interface, display screen, and input devices connected via a system bus. The processor provides determination and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs in the non-volatile storage media. The network interface is used to communicate with an external server via a network connection. When the computer program is executed by the processor, it implements the functions or steps of a cascaded real-time feedback fusion output method on the client side.

[0277] In one embodiment, a computer device is provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to perform the following steps:

[0278] Collect multi-source behavioral data and item information to generate real-time behavioral streams and offline feature sets;

[0279] Based on the asynchronous triggering of the recall channel set, the recall operation is performed on the real-time behavior stream and the offline feature set, and the recall results are fused to generate an initial candidate set.

[0280] Perform a coarse sort on the initial candidate set, and generate a coarsely sorted candidate set by filtering from the initial candidate set according to the truncation condition;

[0281] The real-time behavior stream is processed to generate a real-time feature set, and the real-time feature set is aligned with the offline feature set to obtain an aligned feature set;

[0282] The coarse-ranked candidate set and the alignment feature set are input into the deep ranking model, and the fine-ranked candidate set is generated through the deep ranking model.

[0283] An exploration candidate set is injected into the fine-ranking candidate set through an exploration channel to generate an exploration hybrid set, and the final output set is generated based on the exploration hybrid set.

[0284] Collect feedback data from the final output set, and update the parameters of the recall channel set, the truncation condition for coarse ranking, the weights of the deep ranking model, and the generation strategy for the alignment feature set based on the feedback data set.

[0285] In one embodiment, a computer-readable storage medium is provided having a computer program stored thereon, the computer program performing the following steps when executed by a processor:

[0286] Collect multi-source behavioral data and item information to generate real-time behavioral streams and offline feature sets;

[0287] Based on the asynchronous triggering of the recall channel set, the recall operation is performed on the real-time behavior stream and the offline feature set, and the recall results are fused to generate an initial candidate set.

[0288] Perform a coarse sort on the initial candidate set, and generate a coarsely sorted candidate set by filtering from the initial candidate set according to the truncation condition;

[0289] The real-time behavior stream is processed to generate a real-time feature set, and the real-time feature set is aligned with the offline feature set to obtain an aligned feature set;

[0290] The coarse-ranked candidate set and the alignment feature set are input into the deep ranking model, and the fine-ranked candidate set is generated through the deep ranking model.

[0291] An exploration candidate set is injected into the fine-ranking candidate set through an exploration channel to generate an exploration hybrid set, and the final output set is generated based on the exploration hybrid set.

[0292] Collect feedback data from the final output set, and update the parameters of the recall channel set, the truncation condition for coarse ranking, the weights of the deep ranking model, and the generation strategy for the alignment feature set based on the feedback data set.

[0293] It should be noted that the functions or steps that can be implemented by the computer-readable storage medium or computer device described above can be referred to the relevant descriptions on the server side and client side in the foregoing method embodiments. To avoid repetition, they will not be described one by one here.

[0294] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include non-volatile and / or volatile memory. Non-volatile memory can include read-only memory (ROM), programmable ROM (PROM), electrically programmable ROM (EPROM), electrically erasable programmable ROM (EEPROM), or flash memory. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM is available in various forms, such as static RAM (SRAM), dynamic RAM (DRAM), synchronous DRAM (SDRAM), dual data rate SDRAM (DDRSDRAM), enhanced SDRAM (ESDRAM), synchronous link DRAM (SLDRAM), Rambus direct RAM (RDRAM), direct memory bus dynamic RAM (DRDRAM), and memory bus dynamic RAM (RDRAM), etc.

[0295] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is used as an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above.

[0296] It should be noted that if any software tools or components not belonging to this company appear in the embodiments of this application, they are merely illustrative examples and do not represent actual use. The embodiments described above are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention, and should all be included within the protection scope of the present invention.

Claims

1. A cascaded real-time feedback fusion output method, characterized in that, Includes the following steps: The process involves collecting multi-source behavioral data and item information to generate real-time behavior streams and offline feature sets. This includes: collecting click event streams, search event streams, and page dwell event streams from user interaction logs; aggregating the click event streams, search event streams, and page dwell event streams using time windows to generate a real-time behavior stream; extracting a set of basic item attributes and a set of historical item statistical indicators from an item database; performing discrete feature encoding on the set of basic item attributes to generate a set of static item feature vectors; performing numerical normalization on the set of historical item statistical indicators to generate a set of dynamic item feature vectors; and merging the set of static item feature vectors and the set of dynamic item feature vectors to form an offline feature set. Based on the asynchronous triggering of the recall channel set, the recall operation is performed on the real-time behavior stream and the offline feature set, and the recall results are fused to generate an initial candidate set. Perform a coarse sort on the initial candidate set, and generate a coarsely sorted candidate set by filtering from the initial candidate set according to the truncation condition; The real-time behavior stream is processed to generate a real-time feature set, and the real-time feature set is aligned with the offline feature set to obtain an aligned feature set; The coarse-ranked candidate set and the alignment feature set are input into the deep ranking model, and the fine-ranked candidate set is generated through the deep ranking model. An exploration candidate set is injected into the fine-ranking candidate set through an exploration channel to generate an exploration hybrid set, and the final output set is generated based on the exploration hybrid set. Collect feedback data from the final output set, and update the parameters of the recall channel set, the truncation condition for coarse ranking, the weights of the deep ranking model, and the generation strategy for the alignment feature set based on the feedback data set.

2. The cascaded real-time feedback fusion output method as described in claim 1, characterized in that, A recall operation is asynchronously triggered based on the recall channel set. Recall is performed on the real-time behavior stream and offline feature set, and the recall results are fused to generate an initial candidate set, including: Analyze the recall channel set to determine the collaborative filtering recall channel, vector recall channel, and hotspot recall channel; The collaborative filtering recall channel is triggered asynchronously, and the real-time behavior stream and offline feature set are input into the collaborative filtering recall channel to generate a collaborative filtering item subset. The vector recall channel is asynchronously triggered, and the real-time behavior stream and offline feature set are input into the vector recall channel to generate a vector recall item subset. The hotspot recall channel is triggered asynchronously, and the real-time behavior stream and offline feature set are input into the hotspot recall channel to generate a subset of hotspot items; Monitor the execution status of each recall channel, and terminate the incomplete channel if the execution time of the channel exceeds the preset timeout threshold; Receive the collaborative filtering item subset, vector-recalled item subset, and hot item subset output from the completed recall channel; Merge the collaborative filtering item subset, the vector recall item subset, and the hot item subset to obtain the item set; Perform a deduplication operation on the set of items to generate an initial candidate set.

3. The cascaded real-time feedback fusion output method as described in claim 1, characterized in that, Perform a coarse sort on the initial candidate set, and generate a coarsely sorted candidate set by filtering from the initial candidate set according to the truncation condition, including: Set initial cutoff conditions that include a predefined baseline quantity threshold; Extract the basic feature set of items and the static feature set of users from the initial candidate set; The set of basic features of the items and the set of static features of the users are input into the lightweight ranking model, and the initial screening score of each item is determined by the lightweight ranking model. The items in the initial candidate set are sorted in descending order according to the initial screening scores to obtain a sorted item sequence. Obtain real-time system load metrics; The baseline number threshold of the initial truncation condition is adjusted based on the real-time load index of the system to generate the updated truncation condition; Based on the updated truncation condition, select the set of items that rank first from the sorted item sequence; Generate a coarse-ranked candidate set containing the set of items ranked first.

4. The cascaded real-time feedback fusion output method as described in claim 1, characterized in that, The real-time behavior stream is processed to generate a real-time feature set, and the real-time feature set is aligned with the offline feature set to obtain an aligned feature set, including: The real-time behavior stream is divided into time windows, and the user behavior sequence within each time window is extracted; Transform the user behavior sequence of each time window into a real-time feature vector to generate a real-time feature vector sequence; Extract the historical feature vector corresponding to the time window from the offline feature set; Perform a time dimension alignment operation on the real-time feature vector sequence and the historical feature vector to generate a time-aligned feature set; Perform a standardization and dimensionality reduction operation on the time-aligned feature set to generate a dimension-aligned feature set; Extract the inherent properties of the product from the offline feature set as static features; The alignment feature set is concatenated with the static feature to obtain the alignment feature set.

5. The cascaded real-time feedback fusion output method as described in claim 1, characterized in that, The coarse-ranked candidate set and the alignment feature set are input into a deep ranking model, and a fine-ranked candidate set is generated through the deep ranking model, including: Extract the set of dynamic feature vectors of items from the coarse candidate set; The alignment feature set is divided into a user feature group and a context feature group; The set of dynamic feature vectors of the items, the user feature group, and the context feature group are input into the attention neural network in the deep ranking model, and the item interaction weight matrix is ​​generated by the attention neural network. The deep ranking model performs a weighted fusion operation on the dynamic feature vector set of items based on the item interaction weight matrix to generate a finely ranked feature vector set. The set of fine-ranking feature vectors is input into the fully connected layer of the deep ranking model to determine the fine-ranking score of each item; The items in the coarse-ranked candidate set are sorted in descending order according to the fine-ranking score; Based on a preset fine-ranking threshold, a subset of items is selected from the items sorted in descending order to generate a fine-ranking candidate set.

6. The cascaded real-time feedback fusion output method as described in claim 1, characterized in that, An exploration candidate set is injected into the refined candidate set through an exploration channel to generate an exploration mixture set. Based on this exploration mixture set, a final output set is generated, including: Obtain the exposure frequency data of each item in the item library and generate the item popularity distribution; Retrieve the current user's unexposed item records; Based on the heat distribution of the items and the record of unexposed items, determine the exploration confidence score for each item; Based on the exploration confidence score, a preset number of items are selected for exploration to generate an exploration candidate set; The exploration candidate set and the refined candidate set are merged to generate a merged item set; Perform a deduplication operation on the merged item set to generate an exploration mix set; The output score for each item is extracted from the exploration mix set. The output score is either the ranking score of the ranking candidate item or the exploration confidence score of the exploration candidate item. Sort the items in the exploration mix in descending order based on the output scores; Based on the preset final output quantity threshold, select the first output item subset from the items sorted in descending order; Generate a final output set that includes the subset of the first output items.

7. A cascaded real-time feedback fusion output device, characterized in that, The cascaded real-time feedback fusion output device includes: The data acquisition module is used to collect multi-source behavioral data and item information, and generate real-time behavior streams and offline feature sets. This includes: collecting click event streams, search event streams, and page dwell event streams from user interaction logs; aggregating the click event streams, search event streams, and page dwell event streams using time windows to generate a real-time behavior stream; extracting a set of basic item attributes and a set of historical item statistical indicators from an item database; performing discrete feature encoding on the set of basic item attributes to generate a set of static item feature vectors; performing numerical normalization on the set of historical item statistical indicators to generate a set of dynamic item feature vectors; and merging the set of static item feature vectors and the set of dynamic item feature vectors to form an offline feature set. The recall module is used to asynchronously trigger a recall operation based on the recall channel set, perform recall on the real-time behavior stream and offline feature set, and fuse the recall results to generate an initial candidate set. The coarse sorting module is used to perform coarse sorting on the initial candidate set and to filter and generate a coarsely sorted candidate set from the initial candidate set according to the truncation condition. The feature alignment module is used to process the real-time behavior stream to generate a real-time feature set, and align the real-time feature set with the offline feature set to obtain an aligned feature set; The fine ranking module is used to input the coarse ranking candidate set and the alignment feature set into the deep ranking model, and generate the fine ranking candidate set through the deep ranking model. The exploration injection module is used to inject the exploration candidate set into the fine-ranking candidate set through the exploration channel, generate the exploration mixture set, and generate the final output set based on the exploration mixture set; The feedback optimization module is used to collect feedback data sets of the final output set, and update the parameters of the recall channel set, the truncation conditions of the coarse ranking, the weights of the deep ranking model, and the generation strategy of the alignment feature set based on the feedback data sets.

8. A computer device, characterized in that, The computer device includes a memory, a processor, and a cascaded real-time feedback fusion output program stored in the memory and running on the processor, wherein the cascaded real-time feedback fusion output program, when executed by the processor, implements the steps of the cascaded real-time feedback fusion output method as described in any one of claims 1-6.

9. A computer-readable storage medium, characterized in that, The storage medium stores a cascaded real-time feedback fusion output program, which, when executed by a processor, implements the steps of the cascaded real-time feedback fusion output method as described in any one of claims 1-6.

Images