A real-time recall method for personalized recommendation systems

Abstract

The application discloses a real-time recall method for a personalized recommendation system and relates to the technical field of the personalized recommendation system, and the method is characterized in that: in the current recall process, a 2-fold variance vector is updated by using a 1-fold variance vector; then, a t+1-fold variance vector is updated by using a t-fold variance vector in turn until a z-fold variance vector is obtained; the z-fold variance vector is scaled to a 1-fold variance vector, and the 1-fold variance vector is updated and stored to complete the current recall; in the next recall process, the next recall is performed by using the updated 1-fold variance vector. The application can improve the recall efficiency and the recall effect.

Description

A real-time recall method for personalized recommendation systems Technical Field

[0001] This invention relates to the technical fields of personalized recommendation systems, machine learning, deep learning, and search, and in particular to a real-time recall method for personalized recommendation systems. Background Technology

[0002] Recommendation systems exist in numerous fields, including e-commerce, advertising, and entertainment software. Personalized recommendation systems are generally based on big data technology, analyzing the vast amounts of data stored on servers through machine learning to predict content and items that users may be interested in, thereby improving user experience and increasing user interaction and conversion rates.

[0003] However, recommender systems face the challenge that user interests are constantly changing in real time. Capturing these interests as quickly as possible becomes a technically challenging problem. Traditional online learning algorithms typically use stochastic gradient descent or mini-batch gradient descent to learn from real-time online samples. However, this method of utilizing real-time online samples is very inefficient in terms of sample processing.

[0004] Therefore, many recommendation systems break down recommendation techniques into two parts: recall and re-ranking. The re-ranking part still utilizes machine learning and deep learning techniques, learning from massive amounts of data to obtain a high-performing model. The recall part uses mathematical methods, such as collaborative filtering. Compared to online learning algorithms, mathematical methods often have better sample efficiency, which is beneficial for capturing real-time changes in user interests.

[0005] However, there is still much room for improvement in these mathematical methods. Maximizing real-time sample efficiency remains a difficult problem. Summary of the Invention

[0006] To overcome the shortcomings of the prior art, this invention provides a real-time recall method for personalized recommendation systems, which is similar to the collaborative filtering algorithm, but with significant improvements. Real-time recall using this invention can maximize recall efficiency.

[0007] To achieve the above objectives, the present invention adopts the following technical solution, including:

[0008] A real-time recall method for personalized recommendation systems involves updating a 2x variance vector using a 1x variance vector during the recall process. Then, the variance vector is updated using tx variance vectors sequentially, up to t+1x variance vectors, until the highest variance vector (zx variance vector) is obtained, where 2 ≤ t ≤ z-1. The highest variance vector (zx variance vector) is then scaled down to a 1x variance vector, and the 1x variance vector is updated and stored, completing the recall process.

[0009] In the next recall process, the updated variance vector will be used for the next recall.

[0010] Preferably, real-time recall is performed based on the item_based method, and the specific process is as follows:

[0011] S11, the item description vector in the initial case is the item_based vector, which is called the item_based vector with zero variance;

[0012] The item_based vector represents a vector constructed based on the similarity of items;

[0013] S12, based on the user's interaction, after the user interacts with an item for the first time, obtain the user's item_based vector, which is the user's 1-variance item_based vector, and store the user's 1-variance item_based vector.

[0014] S13, using the user's 1-variance item_based vector, obtain and store the item's 2-variance item_based vector; using the item's 2-variance item_based vector, obtain and store the user's 3-variance item_based vector; using the user's 3-variance item_based vector, obtain and store the item's 4-variance item_based vector; ... using the item's z-1-variance item_based vector, obtain and store the user's z-variance item_based vector;

[0015] S14, scale the user's z-fold variance item_based vector to a 1-fold variance item_based vector, update and store the user's 1-fold variance item_based vector;

[0016] S5. Based on the user's interaction, if the user continues to interact with a certain item, then continue to execute steps S13-S14 to continue real-time recall; otherwise, do not continue to execute steps S13-S14.

[0017] Preferably, real-time recall is performed based on a user-based method, and the specific process is as follows:

[0018] S21, The user's description vector in the initial case is the user_based vector, which is called the user's zero-variance user_based vector;

[0019] The user-based vector represents a vector constructed based on the similarity between users;

[0020] S22, Based on the user's interaction, after the item interacts with a user for the first time, obtain the item's user_based vector, which is the item's 1-variance user_based vector, and store the item's 1-variance user_based vector.

[0021] S23, using the 1-variance user_based vector of the item, obtain the 2-variance user_based vector of the user and store it; using the 2-variance user_based vector of the user, obtain the 3-variance user_based vector of the item and store it; using the 3-variance user_based vector of the item, obtain the 4-variance user_based vector of the user and store it; ... using the z-1-variance item_based vector of the user, obtain the z-variance user_based vector of the item and store it;

[0022] S24, scale the z-fold variance user_based vector of the item to a 1-fold variance user_based vector, update and store the 1-fold variance user_based vector of the item;

[0023] S5. Based on the user's interaction, if the item continues to interact with a user, then continue with steps S23-S24 to continue real-time recall; otherwise, do not continue with steps S23-S24.

[0024] Preferably, the z-fold variance vector is scaled to a 1-fold variance vector by raising the value of each element in the z-fold variance vector to the power of z and then normalizing it, thereby scaling the z-fold variance vector to a 1-fold variance vector.

[0025] The scaling formula is:

[0026]

[0027] The vector contains G elements; x jThis represents the j-th element in the vector; the subscript j indicates the j-th element, j = 1, 2, ... G; x represents the j-th element in the vector. j x to the power of z; x′ j This represents the j-th element in the scaled vector.

[0028] Preferably, in step S11, in the item_based vector of an item, the columns of the vector represent the item number, and the column values ​​of the vector represent the similarity between the current item and the item in the same column. The similarity value ranges from [0, 1], and the larger the similarity value, the more similar the items are.

[0029] Assume there are a total of G i There are G items, i.e., the item_based vectors of the items. i There is an element; initially, an item is only similar to itself and not similar to any other item.

[0030] In the initial case, the j-th i The item_based vector of the j-th item, i.e. i The zero-variance item_based vectors for each item are shown in the table below:

[0031] item_1.......item_j i .......item_G i 00100 surface

[0032] Among them, item_j i Indicates the j-th i Item j i =1,2,...G i The subscript i represents an item; the j-th item i In the zero-variance item_based vector of each item, a column value of 0 indicates that the j-th item... i The similarity between an item and the items in its column is 0; a column value of 1 indicates that the j-th item has a similarity of 0. i The similarity between an item and the items in the same column is 1.

[0033] Preferably, in step S12, in the user's item_based vector, the columns of the vector represent the item numbers, and the column values ​​of the vector represent the user's preference for the items in the corresponding columns. The preference value ranges from [0, 1], and the larger the preference value, the stronger the preference.

[0034] Assume there are a total of G i G items, i.e., the user's item-based vectors, contain a total of G. i There is an element; when a user first interacts with an item, i.e., the j-th element... iAfter interacting with an item, the user's 1x variance item_based vector is obtained, as shown in the table below:

[0035] item_1.......item_j i .......item_G i 00100 surface

[0036] Among them, item_j i Indicates the j-th i Item j i =1,2,...G i The subscript i represents an item; in the user's 1x variance item_based vector, a column value of 0 indicates that the user's preference for the item in that column is 0, and a column value of 1 indicates that the user's preference for the item in that column is 1.

[0037] Preferably, in step S21, in the user_based vector, the columns of the vector represent the user's ID, and the column values ​​of the vector represent the similarity between the current user and the user in the same column. The similarity value ranges from [0, 1], and the larger the similarity value, the more similar the user is.

[0038] Assume there are a total of G u There are G users, that is, a total of G user-based vectors. u There is an element; initially, a user is only similar to themselves and not similar to any other user; the j-th element in the initial case... u The user-based vector of the j-th user, i.e., the user-based vector of the j-th user. u The zero-variance user_based vectors for each user are shown in the table below:

[0039] item_1.......item_j u .......item_G u 00100 surface

[0040] Among them, item_j u Indicates the j-th u One user, j u =1,2,...G u The subscript u represents the user; the j-th subscript represents the user. u In the zero-variance user_based vector for each user, a column value of 0 indicates that the j-th user... u The similarity between a user and the user in the same column is 0; a column value of 1 indicates that the j-th user has a similarity of 0. u The similarity between each user and the users in the same column is 1.

[0041] Preferably, in step S22, in the user_based vector of the item, the columns of the vector represent the user's ID, and the column values ​​of the vector represent the user's preference for the item in that column. The preference value ranges from [0, 1], and the larger the preference value, the stronger the preference.

[0042] Assume there are a total of G u There are G user-based vectors for each user and item. u There is an element; when an item first interacts with a user, i.e., the j-th element... u After each user interacts, the 1-variance user_based vector of the item is obtained, as shown in the table below:

[0043] item_1.......item_j u .......item_G u 00100 surface

[0044] Among them, item_j u Indicates the j-th u One user, j u =1,2,...G u The subscript u represents the user; in the 1-variance user_based vector of the item, a column value of 0 indicates that the user in that column has a preference of 0 for the item, and a column value of 1 indicates that the user in that column has a preference of 1 for the item.

[0045] Preferably, in step S13 or step S23,

[0046] The formula for calculating the b+1 times variance of the item_based / user_based vector is:

[0047] i(b+1)=u(b)×γ i +i(b-1)×(1-γ i )

[0048] Where, γ i This represents the item vector update coefficient, where the index i represents the item, and γ... i `b` is a fixed parameter, specifically a decimal between 0 and 1; `b` represents the variance factor; `i(·)` represents the item variance vector (item_based / user_based); `u(·)` represents the user variance vector (item_based / user_based); `i(b+1)` is the item variance vector (item_based / user_based) multiplied by 1; `i(b-1)` is the item variance vector (item_based / user_based) multiplied by 1; `u(b)` is the user variance vector (item_based / user_based) multiplied by 1.

[0049] The formula for calculating the user's (a+1) times variance item_based / user_based vector is:

[0050] u(a+1)=i(a)×γ u +u(a-1)×(1-γ u )

[0051] Where, γ u This represents the user vector update coefficient, where the subscript u represents the user, and γ... u is a fixed parameter, specifically a decimal between 0 and 1; 'a' represents the variance multiple; 'i(·)' represents the item variance vector (item_based / user_based); 'u(·)' represents the user variance vector (item_based / user_based); 'u(a+1)' is the user's (a+1) times variance vector (item_based / user_based); 'u(a-1)' is the user's (a-1) times variance vector (item_based / user_based); 'i(a)' is the item's (a) times variance vector (item_based / user_based).

[0052] Preferably, or in step S13 or step S23,

[0053] The formula for calculating the b+1 times variance of the item_based / user_based vector is:

[0054] i(b+1)=u(b)×γ i / n+i(b-1)×(1-γ i / n)

[0055] Where, γ i This represents the item vector update coefficient, where the index i represents the item, and γ... i `n` is a fixed parameter, specifically a decimal between 0 and 1; `n` is the number of times the item is interacted with; `b` represents the variance factor; `i(·)` represents the item's variance vector (item_based / user_based); `u(·)` represents the user's variance vector (item_based); `i(b+1)` is the item's variance vector (item_based / user_based); `i(b-1)` is the item's variance vector (item_based / user_based); `u(b)` is the user's variance vector (item_based / user_based).

[0056] The formula for calculating the user's (a+1) times variance item_based / user_based vector is:

[0057] u(a+1)=i(a)×γ u / m+u(a-1)×(1-γ u / m)

[0058] Where, γ u This represents the user vector update coefficient, where the subscript u represents the user, and γ... u `m` is a fixed parameter, specifically a decimal between 0 and 1; `m` is the number of user interactions; `a` represents the variance factor; `i(·)` represents the item variance vector (`item_based / user_based`); `u(·)` represents the user variance vector (`item_based / user_based`); `u(a+1)` is the user variance vector (`item_based / user_based` by factor `a+1`); `u(a-1)` is the user variance vector (`item_based / user_based` by factor `a-1`); `i(a)` is the item variance vector (`item_based / user_based` by factor `a`.

[0059] The advantages of this invention are:

[0060] (1) This invention provides a real-time recall method for personalized recommendation systems, which is similar to the collaborative filtering algorithm, but with important improvements. Real-time recall using the method of this invention can maximize recall efficiency.

[0061] (2) The more vector records there are, the more related items can be seen in the highest variance vector, which means the recall effect is better, and more related items are recalled. However, the update methods in the prior art all use the low variance vector to update the high variance vector, so the amount of data will become larger and larger. Even with sparse storage, it will be unbearable as the amount of data increases. To this end, the present invention uses the high variance vector to update the low variance vector, which scales the high variance vector to the low variance vector and replaces the low variance vector, so that it can continue to be updated in the next calculation, which greatly improves the recall efficiency and recall effect. Attached Figure Description

[0062] Figure 1 is a flowchart of a real-time recall method for a personalized recommendation system based on the item_based method in Example 1.

[0063] Figure 2 is a flowchart of a real-time recall method for a personalized recommendation system based on the user-based method in Example 2. Detailed Implementation

[0064] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0065] Taking e-commerce as an example, an e-commerce scenario involves users and items. Users interact with items online in real time, such as clicking, adding to cart, and purchasing. Collaborative filtering algorithms for item recall include item-based and user-based methods.

[0066] The `item-based` method specifically recommends items similar to a user's previously liked items. Item-based recommendations primarily consider the user's historical interests, suggesting items similar to those the user has historically liked. This is highly relevant to the user's current behavior, and the similarity between recommended items and the user's current clicks (interacting with items) is understandable to the user—meaning it's highly explainable. The recommended items are not necessarily popular; they may even be less common, but they are related to the user's interests. This requires the user's interests on the website to be long-term and consistent. The purpose of the recommendations is to help users find items related to their interests. Since the recommended items are not heavily dependent on the user's specific profile, it effectively addresses the issue of new users.

[0067] The user-based method specifically recommends items liked by users with similar interests. It prioritizes the interests of users with shared hobbies, recommending items these users have liked or visited. This is less related to the user's current behavior and more to what their friends have visited, reflecting a social network. The recommended items are those most frequently accessed by users with similar interests, thus exhibiting a trending effect – recommending items most visited by users within the same social circle. It can also recommend items recently visited by users within the circle, providing strong real-time updates, especially for newly introduced trending items, allowing for rapid dissemination and solving the cold start problem for new items.

[0068] Example 1

[0069] This embodiment 1 uses the item_based method as an example to illustrate the current recall methods:

[0070] Initially, each item is only similar to itself, and can be described by a normalized vector, namely the item description vector, or item_based vector. Here, item_based represents the vector constructed based on the similarity between items. The columns of the item_based vector are the item IDs, and the column values ​​represent the similarity between the current item and the items in the same column. The similarity value ranges from [0, 1], with a higher similarity value indicating greater similarity.

[0071] Assume there are a total of G i Item G i =3, item_1, item_2, and item_3 represent the first, second, and third items, respectively, as shown in Table 1 below. Table 1 is the item_based vector of item_1 in the initial case, that is, the item_based vector of the first item in the initial case.

[0072] Table 1 shows the item-based vector of item_1 in the initial case.

[0073] item_1item_2item_3100 surface

[0074] Among them, item_j i Indicates the j-th i Item j i =1,2,...G i The subscript i represents an item.

[0075] Since there are three items in total, the item-based vectors are three-dimensional. Table 1 shows the initial state of item_1's item-based vector: initially, item_1 is only similar to itself, and dissimilar to item_2 and item_3. The item_based vector of item_1 is stored in the database. Due to the massive amount of data in scenarios like the internet, this data is sparsely stored; therefore, only the first column is actually stored.

[0076] Initially, the user's description vector, i.e., the user's item-based vector, is a uniform vector, meaning that the user's preference for any item is consistent. However, since the user has not interacted with anything at this point, the user's item-based vector is not actually stored initially. The user's item-based vector is only truly stored when the user interacts with an item, such as clicking, adding to the cart, or purchasing an item. When the user interacts with an item for the first time, the user's item-based vector is immediately updated and stored. For example, if the user interacts with item_2, the user's item-based vector will become as shown in Table 2 below.

[0077] Table 2. User item-based vectors after user interaction with item_2.

[0078] item_1item_2item_3010 surface

[0079] In the user's item_based vector, the columns of the vector represent the item numbers, and the column values ​​represent the user's preference for the items in that column. The preference value ranges from [0, 1], and the larger the preference value, the stronger the preference.

[0080] The initial item-based vector, as shown in Table 1, is called the item's zero-variance item-based vector. It's called a variance-based vector because we consider the user's interaction with the item as a measurement process. When a user interacts with an item, it means that the user's preferred item attributes are similar to those of the item; this can be seen as a measurement. Similarly, the updated user item-based vector after the user interacts with the item is called the user's one-variance item-based vector, as shown in Table 2.

[0081] The user's item_based vector is updated using a sliding filter method to obtain the user's a+1 times variance item_based vector. The formula for calculating the user's a+1 times variance item_based vector is as follows:

[0082] u(a+1)=i(a)×γ u +u(a-1)×(1-γ u Equation (1)

[0083] Where, γ u This represents the user vector update coefficient, where the subscript u represents the user, and γ... uis a fixed parameter, specifically a decimal between 0 and 1; 'a' represents the variance multiple; 'i(·)' represents the item variance vector; 'u(·)' represents the user variance vector; 'u(a+1)' is the user's (a+1) times variance vector; 'u(a-1)' is the user's (a-1) times variance vector; 'i(a)' is the item's (a) times variance vector.

[0084] This associates the user's item-based vector with more items, but these are all items the user has interacted with. To recommend items the user hasn't interacted with, the variance of the vector needs to be increased to associate it with more items. One approach is to use the user's item-based vector to update the item's item-based vector, but this directly results in different variances, making the updates messy.

[0085] Therefore, we can separately record an item's 2x variance item_based vector, and then update the item's item_based vector using an update method similar to that used for user's item_based vector, to obtain the item's b+1x variance item_based vector. The formula for calculating the item's b+1x variance item_based vector is as follows:

[0086] i(b+1)=u(b)×γ i +i(b-1)×(1-γ i Equation (2)

[0087] Where, γ i This represents the item vector update coefficient, where the index i represents the item, and γ... i is a fixed parameter, specifically a decimal between 0 and 1; b represents the variance multiple; i(·) represents the item variance vector; u(·) represents the user variance vector; i(b+1) is the item variance vector at multiples of b+1; i(b-1) is the item variance vector at multiples of b-1; u(b) is the user variance vector at multiples of b.

[0088] Following the same method, we can update and store a user's 3x variance item_based vector, an item's 4x variance item_based vector, and so on. The more vectors recorded, the more associated items can be seen in the user's highest variance item_based vector, which means the recall effect is better, and more associated items have been recalled.

[0089] At the same time, it will also update and record the cumulative number of user interactions m and the number of times items have been interacted with over a period of time, which will be used to slide and update the user's item_based vector and the item's item_based vector.

[0090] Since the above update methods all use low-variance item_based vectors to update high-variance item_based vectors, the amount of data will become increasingly large. Even with sparse storage, it will become unmanageable as the amount of data increases.

[0091] The present invention provides a real-time recall method for a personalized recommendation system, which specifically involves the following steps: In the current recall process, first, the variance vector is updated using a 1x variance vector to update a 2x variance vector; then, the variance vector is updated using a tx variance vector to update a t+1x variance vector sequentially until the highest variance vector, i.e., a zx variance vector, is obtained, where 2 ≤ t ≤ z-1; then, the highest variance vector, i.e., a zx variance vector, is scaled down to a 1x variance vector, and the 1x variance vector is updated and stored to complete the current recall; in the next recall process, the updated 1x variance vector is used for the next recall.

[0092] This invention uses a high-variance vector to update a low-variance vector, that is, it scales the high-variance vector to the low-variance vector. The scaling formula is as follows:

[0093]

[0094] Among them, the vector has G elements; x j This represents the j-th element in the vector; the subscript j indicates the j-th element, j = 1, 2, ... G; x represents the j-th element in the vector. j x to the power of z; x′ j This represents the j-th element in the scaled vector.

[0095] The above update is performed on each element of the vector, that is, the value of each element in the z-fold variance vector is raised to the power of z, and then normalized, thereby scaling the z-fold variance vector to a 1-fold variance vector. For example, for a 4-fold variance vector, the value of each element is raised to the power of 4, and then the vector is re-normalized, so that the vector becomes a 1-fold variance vector. Then, this 1-fold variance vector can be used to update the 2-fold variance vector, thus achieving the effect of using a high-fold variance vector to update a low-fold variance vector. Therefore, after using a high-fold variance vector to update a low-fold variance vector, the update process of this invention can be transformed into a loop.

[0096] As shown in Figure 1, the item-based method of this embodiment 1, a real-time recall method for personalized recommendation systems, is as follows:

[0097] S11, the item description vector in the initial case is the item_based vector, which is called the item_based vector with zero variance; the item_based vector with zero variance does not need to be stored.

[0098] The item_based vector represents a vector constructed based on the similarity of items.

[0099] S12: Based on the user's interaction, after the user interacts with an item for the first time, obtain the user's 1x variance item_based vector and store the user's 1x variance item_based vector.

[0100] S13, using the user's 1-fold variance item_based vector and according to the formula (2), obtain the item's 2-fold variance item_based vector and store it; using the item's 2-fold variance item_based vector and according to the formula (1), obtain the user's 3-fold variance item_based vector and store it; ... using the item's z-1-fold variance item_based vector and according to the formula (1), obtain the user's z-fold variance item_based vector and store it.

[0101] S14. Using the user's z-fold variance item_based vector, according to the scaling formula in equation (3), the value of each element in the vector is raised to the power of z, and then re-normalized to scale the z-fold variance item_based vector to the 1-fold variance item_based vector. The user's 1-fold variance item_based vector is then updated and stored.

[0102] In this case, z will not take an unlimitedly large value, in order to achieve a balance between storage and recall effects.

[0103] S5. Based on the user's interaction, if the user continues to interact with a certain item, then continue to execute steps S13-S14 to continue real-time recall; otherwise, do not continue to execute steps S13-S14.

[0104] In recommendation systems, items that have already been interacted with by users have a higher probability of being interacted with again; this is known as the Matthew effect problem. In this invention, the number of user interactions *m* and the number of item interactions *n* over a given period can be recorded. By modifying the filtering formula, a fixed parameter γ is applied. u γ iThe coefficients are transformed into those related to m and n, thus alleviating the Matthew effect problem. The modified formulas for calculating the user's a+1 times variance item_based vector and the item's b+1 times variance item_based vector are as follows:

[0105] u(a+1)=i(a)×γ u / m+u(a-1)×(1-γ u / m) Equation (4)

[0106] i(b+1)=u(b)×γ i / n+f(b-1)×(1-γ i / n) Equation (5)

[0107] Where, γ u γ i It is a smoothing coefficient, also known as an update coefficient, and is a hyperparameter. Generally, γ u γ i The values ​​can be the same; m is the number of user interactions; n is the number of times the item is clicked.

[0108] Thus, the recall method of the present invention has achieved all the required objectives.

[0109] The recall method of this invention can vary slightly depending on the specific scenario. Some scenarios require a certain Matthew effect, such as the content recommendation field, where good content does indeed need more recommendations. In this case, the update formulas for the user's item_based vector and the item's item_based vector can directly adopt equations (1) and (2) to obtain the high-variance item_based vectors of the user and the item. Alternatively, to achieve more precise adjustment, the k-th power can be taken from m and n based on equations (4) and (5).

[0110] Example 2

[0111] This embodiment 2 presents a user-based method, a real-time recall method for personalized recommendation systems, as detailed below:

[0112] S21, the user's description vector in the initial case is the user_based vector, which is called the user's zero-variance user_based vector; the user's zero-variance user_based vector does not need to be stored.

[0113] The user-based vector represents a vector constructed based on the similarity between users.

[0114] In the user_based vector, the columns of the vector represent the user's ID, and the column values ​​represent the similarity between the current user and the user in the same column. The similarity value ranges from [0, 1], and the higher the similarity value, the more similar the user is.

[0115] Assume there are a total of G u There are G users, that is, a total of G user-based vectors. u There is one element. Initially, a user is only similar to themselves and not similar to any other user. The j-th element in the initial state... u The user-based vector of the j-th user, i.e., the user-based vector of the j-th user. u The zero-variance user_based vectors for each user are shown in the table below:

[0116] item_1.......item_j u .......item_G u 00100 surface

[0117] Among them, item_j u Indicates the j-th u One user, j u =1,2,...G u The subscript u represents the user; the j-th subscript represents the user. u In the zero-variance user_based vector for each user, a column value of 0 indicates that the j-th user... u The similarity between a user and the user in the same column is 0; a column value of 1 indicates that the j-th user has a similarity of 0. u The similarity between each user and the users in the same column is 1.

[0118] S22. Based on the user's interaction, after the item interacts with a user for the first time, obtain the item's user_based vector, which is the item's 1-variance user_based vector, and store the item's 1-variance user_based vector.

[0119] In the user-based vector of an item, the columns of the vector represent the user's ID, and the column values ​​represent the user's preference for the item. The preference value ranges from [0, 1], and the larger the preference value, the stronger the preference.

[0120] There are a total of G u There are G user-based vectors for each user and item. u There is an element. When an item first interacts with a user, i.e., the j-th element... u After each user interacts, the 1-variance user_based vector of the item is obtained, as shown in the table below:

[0121] item_1.......item_j u .......item_G u 00100 surface

[0122] Among them, item_j u Indicates the j-th u One user, j u =1,2,...G u The subscript u represents the user; in the 1-variance user_based vector of the item, a column value of 0 indicates that the user in that column has a preference of 0 for the item, and a column value of 1 indicates that the user in that column has a preference of 1 for the item.

[0123] Initially, the item's description vector, i.e., the item's user-based vector, is a uniform vector, meaning that any user has the same preference for the item. However, since the user has not performed any actions at this time, the item's user-based vector is not actually stored in the initial case.

[0124] S23, using the 1-fold variance user_based vector of the item and referring to equation (1) of Example 1, obtain and store the 2-fold variance user_based vector of the user; using the 2-fold variance user_based vector of the user and referring to equation (2) of Example 1, obtain and store the 3-fold variance user_based vector of the item; using the 3-fold variance user_based vector of the item and referring to equation (1) of Example 1, obtain and store the 4-fold variance user_based vector of the user; ... using the z-1-fold variance item_based vector of the user and referring to equation (2) of Example 1, obtain and store the z-fold variance user_based vector of the item.

[0125] S24. Scale the z-fold variance user_based vector of the item. According to the scaling formula in equation (3), raise the value of each element in the vector to the power of z, and then re-normalize it to scale the z-fold variance user_based vector of the item to the 1-fold variance user_based vector. Update and store the 1-fold variance user_based vector of the item.

[0126] In this case, z will not take an unlimitedly large value, in order to achieve a balance between storage and recall effects.

[0127] S5. Based on the user's interaction, if the item continues to interact with a user, then continue with steps S23-S24 to continue real-time recall; otherwise, do not continue with steps S23-S24.

[0128] In recommendation systems, items that have already been interacted with by users have a higher probability of being interacted with by similar users; this is known as the Matthew effect problem in recommendation systems. In this invention, the number of user interactions *m* and the number of times an item has been interacted with over a given period *n* can be recorded. By modifying the filtering formula, a fixed parameter γ is applied. u γ i The coefficients are transformed into those related to m and n, which can alleviate the Matthew effect problem. The calculation formulas for the modified user's a+1 times variance uesr_based vector and the item's b+1 times variance uesr_based vector are respectively referred to Equation (4) and Equation (5) of Example 1.

[0129] The above are merely preferred embodiments of the present invention and are not intended to limit the scope of the present invention. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A real-time recall method for a personalized recommendation system, characterized in that, In this recall process, the 2-fold variance vector is first updated using the 1-fold variance vector; then, it is sequentially updated using... Variance vector update Multiply the variance vector until the highest multiple is obtained. Variance vector ； Then for the highest multiple, i.e. The variance vector is scaled to 1x variance vector and updated and stored, completing this recall. In the next recall process, the updated 1x variance vector is used for the next recall. Real-time recall is based on the item_based method, and the specific process is as follows: S11, the item description vector in the initial case is the item_based vector, called the item's 0x variance item_based vector; the item_based vector represents the vector constructed based on the similarity of items; S12, based on the user's interaction, after the user interacts with an item for the first time, the following is obtained: The user's item_based vector is the user's 1-variance item_based vector, and this 1-variance item_based vector is stored; S13, using the user's 1-variance item_based vector, the 2-variance item_based vector is obtained and stored; using the item's 2-variance item_based vector, the 3-variance item_based vector is obtained and stored; using the user's 3-variance item_based vector, the 4-variance item_based vector is obtained and stored; ... using the item's Double-variance item_based vectors to obtain user data S14, for the user's item_based vector and store it; Scaling the variance-based item-based vector to scale the user's... S1. Scale the variance-based item_based vector to a variance-based item_based vector, update and store the user's variance-based item_based vector; S5. Based on the user's interaction, if the user continues to interact with a certain item, continue to execute steps S13-S14 to continue real-time recall; otherwise, do not continue to execute steps S13-S14.

2. The real-time recall method for a personalized recommendation system according to claim 1, characterized in that, Alternatively, real-time recall can be performed based on a user-based method, with the following process: S21, the initial user description vector, i.e., the user's user-based vector, is called the user's 0-fold variance user-based vector; the user-based vector represents a vector constructed based on user similarity; S22, based on user interaction, after an item interacts with a user for the first time, the item's user-based vector, i.e., the item's 1-fold variance user-based vector, is obtained and stored; S23, using the item's 1-fold variance user-based vector, the user's 2-fold variance user-based vector is obtained and stored; using the user's 2-fold variance user-based vector, the item's 3-fold variance user-based vector is obtained and stored; using the item's 3-fold variance user-based vector, the user's 4-fold variance user-based vector is obtained and stored; ... using the user's... The variance-based item_based vector is used to obtain the item's... S24, generate and store the variance-based user-based vector; for items... Scaling the variance-based user-based vector to scale the items S23-S24: Scale the user-based vector with double variance to a user-based vector with 1 variance, update and store the user-based vector with 1 variance for the item; S5: Based on the user's interaction, if the item continues to interact with a user, continue to execute steps S23-S24 to continue real-time recall; otherwise, do not continue to execute steps S23-S24.

3. A real-time recall method for a personalized recommendation system according to claim 1 or 2, characterized in that, Will Scaling a variance vector from one-fold to one-fold is done by scaling the variance vector as follows: The value of each element in the variance vector is taken as follows The power is then normalized to achieve the desired result. Scaling a variance vector from one-fold variance to one-fold variance; the scaling formula is: Among them, the vector has a total of One element; Represents the first in the vector One element; subscript Indicates the first One element, ； Represents the first in the vector element of Power; Represents the first element in the scaled vector. Each element.

4. The real-time recall method for a personalized recommendation system according to claim 1, characterized in that, In step S11, in the item_based vector, the columns of the vector represent the item's ID, and the column values ​​represent the similarity between the current item and the items in the same column. The similarity value ranges from [value missing]. A higher similarity value indicates greater similarity; assuming there are multiple similarities... There are 100 items, that is, the item_based vectors of the items. There is one element; initially, an item is only similar to itself and not similar to any other item; the initial state of the first element... The item-based vector of the nth item, i.e., the th... The zero-variance item_based vectors for each item are shown in the table below: Among them, item_ Indicates the first One item, ; Subscript Characterizing items; the first In the zero-variance item_based vector, a column value of 0 indicates that the item is... The similarity between an item and the items in its column is 0; a column value of 1 indicates that the similarity between the item and the item in the column is 0. The similarity between an item and the items in the same column is 1.

5. The real-time recall method for a personalized recommendation system according to claim 1, characterized in that, In step S12, in the user's item_based vector, the columns of the vector represent the item numbers, and the column values ​​represent the user's preference for the items in that column. The preference values ​​range from [value missing]. A higher preference value indicates a stronger preference; assuming there are a total of There are 10 items, i.e., the user's item_based vector. There is an element; When a user first interacts with an item, that is, the After interacting with an item, the user's 1x variance item_based vector is obtained, as shown in the table below: Among them, item_ Indicates the first One item, ; Subscript In the item_based vector representing items and users, a column value of 0 indicates that the user's preference for the item in that column is 0, and a column value of 1 indicates that the user's preference for the item in that column is 1.

6. A real-time recall method for a personalized recommendation system according to claim 2, characterized in that, In step S21, in the user_based vector, the columns of the vector represent the user's ID, and the column values ​​represent the similarity between the current user and the users in the same column. The similarity value ranges from [value missing]. A higher similarity value indicates greater similarity; assuming there are multiple similarities... There are [number] users, meaning that the user_based vector of each user contains [number] users. The first element; initially, a user is only similar to themselves and not similar to any other user; the first element in the initial case... The user-based vector of the i-th user, i.e., the _i-th user The zero-variance user_based vectors for each user are shown in the table below: Among them, item_ Indicates the first One user, ; Subscript Representing the user; the first In the zero-variance user_based vector for each user, a column value of 0 indicates that the first user... The similarity between the current user and the user in the same column is 0; a column value of 1 indicates that the similarity between the current user and the user in the same column is 0. The similarity between each user and the users in the same column is 1.

7. A real-time recall method for a personalized recommendation system according to claim 2, characterized in that, In step S22, in the user-based vector of the item, the columns of the vector represent the user's ID, and the column values ​​represent the user's preference for the item in that column. The preference value ranges from [value missing]. A higher preference value indicates a stronger preference; assuming there are a total of There are a total of [number] users, i.e., [number] items in the user-based vector. There is an element; when an item first interacts with a user, that is, the first... After each user interacts, the 1-variance user_based vector of the item is obtained, as shown in the table below: Among them, item_ Indicates the first One user, ; Subscript In the user_based vector representing users and items with a variance of 1, a column value of 0 indicates that the user in that column has a preference of 0 for the item, and a column value of 1 indicates that the user in that column has a preference of 1 for the item.

8. A real-time recall method for a personalized recommendation system according to claim 1 or 2, characterized in that, In step S13 or step S23, the item's The formula for calculating the variance of the item_based / user_based vector is: in, Indicates the item vector update coefficient, index Characterizing objects, It is a fixed parameter, specifically a decimal number between 0 and 1; Indicates the variance multiple; A vector representing the variance of the items (item_based / user_based). This represents the variance of the user (item_based / user_based vector). For items Variance of item_based / user_based vectors; For items Variance of item_based / user_based vectors; For users Double-variance item_based / user_based vectors; user The formula for calculating the variance of the item_based / user_based vector is: in, Indicates the user vector update coefficients, subscript Representing users, It is a fixed parameter, specifically a decimal number between 0 and 1; Indicates the variance multiple; A vector representing the variance of the items (item_based / user_based). This represents the variance of the user (item_based / user_based vector). For users Variance of item_based / user_based vectors; For users Variance of item_based / user_based vectors; For items Variance of item_based / user_based vectors.

9. A real-time recall method for a personalized recommendation system according to claim 1 or 2, characterized in that, Alternatively, in step S13 or step S23, the item's The formula for calculating the variance of the item_based / user_based vector is: in, Indicates the item vector update coefficient, index Characterizing objects, It is a fixed parameter, specifically a decimal number between 0 and 1; The number of times the item has been interacted with; Indicates the variance multiple; A vector representing the variance of the items (item_based / user_based). This represents the user's variance item-based vector; For items Variance of item_based / user_based vectors; For items Variance of item_based / user_based vectors; For users Double-variance item_based / user_based vectors; user The formula for calculating the variance of the item_based / user_based vector is: in, Indicates the user vector update coefficients, subscript Representing users, It is a fixed parameter, specifically a decimal number between 0 and 1; The number of times a user interacts; Indicates the variance multiple; A vector representing the variance of the items (item_based / user_based). This represents the variance of the user (item_based / user_based vector). For users Variance of item_based / user_based vectors; For users Variance of item_based / user_based vectors; For items Variance of item_based / user_based vectors.

Images