Detailed Description
The following description of the embodiments of the present application will be made clearly and completely with reference to the accompanying drawings, in which it is evident that the embodiments described are only some embodiments of the present application, but not all embodiments. All other embodiments, which can be made by those skilled in the art based on the embodiments of the application without making any inventive effort, are intended to fall within the scope of the application.
As shown in fig. 1, the application scenario of the present application includes a computer system 10 and a terminal cluster, where the terminal cluster may include one or more terminals, and the number of terminals will not be limited herein. As shown in fig. 1, the terminal cluster may specifically include a terminal 1, a terminal 2, …, and a terminal n; it will be appreciated that terminals 1, 2,3, …, n may each be networked to the computer system 10 so that each may interact with data from the computer system 10 via the network connection.
It is understood that the computer system 10 may refer to a device performing the method of the application, which computer system 10 may also be used for storing data to be processed. The computer system 10 may be a server, which may be a separate physical server, a server cluster or a distributed system formed by at least two physical servers, or may be a cloud server that provides cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communication, middleware services, domain name services, security services, a content delivery network (Content Delivery Network, CDN), and basic cloud computing services such as big data and an artificial intelligence platform. The terminal may specifically be a terminal where an application program of the payment function is located, for example, a smart phone, a tablet computer, a notebook computer, a smart watch, and the like, but is not limited thereto. The terminals and the servers may be directly or indirectly connected through wired or wireless communication, and meanwhile, the number of the terminals and the servers may be one or at least two, which is not limited herein.
Further, please refer to fig. 2, which is a flow chart of a data processing method for multi-platform aggregate payment according to an embodiment of the present application. As shown in fig. 2, the method comprises the steps of:
Step S10: acquiring a first security code array, a first user characteristic array and a first consumer product array uploaded by a first payment platform, and a second security code array, a second user characteristic array and a second consumer product array uploaded by a second payment platform; the first security coding array is a security coding array of a first interaction array of a user set for a first consumer product set, the first user feature array and the first consumer product array are model parameter arrays of the first interaction array, the second security coding array is a security coding array of a second interaction array of the user set for a second consumer product set, and the second user feature array and the second consumer product array are model parameter arrays of the second interaction array.
In an exemplary application scenario, it is assumed that there are two main online payment platforms, platform a and platform B, which serve different e-commerce domains, respectively, such as platform a focusing on electronic product sales, and platform B playing books and educational products. In order to enhance user experience and sales, the two platforms decide to cooperate, collectively analyze user behavior through a multi-platform aggregate payment data processing system, predict user purchasing trends, and provide more personalized services accordingly.
The computer system first ensures that a secure, stable data transmission channel is established with platform a and platform B. These channels may be based on the HTTPS protocol, ensuring encryption and integrity of data during transmission. At the same time, the system is also configured with necessary security authentication mechanisms, such as API keys, OAuth tokens, etc., to prevent unauthorized access.
Firstly, uploading data of a first payment platform (platform A), and encrypting interaction data (such as clicking, browsing, purchasing records and the like) between a user and an electronic product collected by the platform A to generate a first security coding array. For example, with a symmetric encryption algorithm (e.g., AES) or an asymmetric encryption algorithm (e.g., RSA), the specific choice depends on security requirements and performance considerations. The encrypted array is uploaded to a computer system in a binary or Base64 coding mode, so that the security of data in the transmission and storage processes is ensured.
For example, suppose that platform a records how many clicks, browsing durations, and final purchases a user Alice has made on a smartphone during the last week, encoded as an encrypted array, such as Enc (click=5), enc (ViewTime =300), enc (Purchase=1), where Enc () represents the encryption function.
At the same time, platform a also uploads an array describing the potential characteristics or relationships of the user and consumer product. The user characteristic array may contain information such as age, gender, geographic location, historical purchase preferences, etc.; the consumer product array then contains product price, category, brand, user rating, etc.
For example, one example of a user feature array is [ [25, 'female', 'Beijing', [30, 'male', 'Shanghai', ] where each row represents the age, gender, and geographic location of a user. One example of a consumer product array is [ [ 'smart phone', 5000, 'Apple', 4.8], [ 'notebook', 8000, 'Dell', 4.6] ], representing product name, price, brand, and average user score, respectively.
Then, the data of the second payment platform (platform B) is uploaded, and similar to platform a, platform B also encrypts and uploads the collected interaction data between the user and the books and education supplies, the user characteristic array and the consumer product array. Except that the specific content of these data reflects the traffic characteristics of platform B.
The second security code array contains encrypted records of user interactions such as browsing, purchasing of books and educational software. For example, browsing and purchasing behavior of a programmed book as by user Bob is encrypted as Enc (view=1), enc (purchase=1).
A second user profile array and a second consumer product array: the user characteristic array may contain information such as reading habit, education level and the like of the user; the consumer product array then details the ISBN, author, publisher, reader's rating, etc. of the book.
For example, one example of a user feature array is [ [28, 'Man','software engineering master', ] [35, 'woman','education doctor', ]. An example of a consumer product array is [ ('Python programming from entry to practice', '9787115524486', 'ERIC MATTHES', 4.9], [ 'educational psychology', '9787303245452', 'tensor', 4.7] ].
In computer systems, these uploaded arrays are typically stored and processed in a matrix form. The rows of the matrix represent different users or products and the columns correspond to specific features or interactions. For example, the first column of the user feature matrix may be age, the second column is gender, and so on. Such a data structure facilitates subsequent matrix operations and training of machine learning models.
Step S10 emphasizes the importance of data encryption, which is key to protecting user privacy and compliance with relevant laws and regulations. Through encryption processing, even if data is intercepted in the transmission or storage process, an attacker cannot directly acquire sensitive information. At the same time, the computer system should ensure that only authorized personnel or systems can access and decode the data.
Step S10 is used as the first step of a multi-platform aggregate payment data processing flow, and a solid foundation is laid for subsequent data integration, model debugging and consumption reasoning by safely and efficiently collecting key data from different payment platforms. In this process, the computer system not only ensures the integrity and security of the data, but also provides convenience for subsequent data processing and analysis work through standardized data formats and structures. Through the implementation of the step, the data among different payment platforms can be shared and utilized on the premise of not directly exchanging sensitive information, the development of personalized services is promoted together, and the user experience and the sales conversion rate are improved.
Step S20: and decoding and integrating the first security coding array and the second security coding array to obtain an integrated interaction array of the first interaction array and the second interaction array.
Continuing with the previously set scenario, platform A and platform B upload their respective security code arrays of user and product interaction data, and corresponding user feature arrays and consumer product arrays, respectively. The task of the computer system is to decode and integrate these encrypted interaction data into an integrated interaction array that reflects the user's cross-platform behavior.
The computer system firstly selects a corresponding decryption algorithm according to the encryption algorithm used by the platform A and the platform B when uploading data. Since the encryption mode (such as AES symmetric encryption) has been already agreed before, the system can directly apply the corresponding decryption function to decrypt. For each security encoding array, the system applies a decryption function element by element, restoring it to the original interaction data. Such interaction data may include the number of clicks, duration of browsing, purchasing behavior, etc. of the user, depending on the data collection policy of the platform.
For example, assuming that the encryption array [ Enc (click=5), enc (ViewTime =300), enc (Purchase=1 ] is uploaded by platform a, the system obtains a decryption array [ click=5, viewTime =300, purchase=1 ] after applying the AES decryption algorithm. After decoding to obtain the interaction array of the two platforms, the computer system needs to find the common user across the platforms. This is typically matched by user ID. The system traverses the user IDs of the two arrays to find out the common user present on the two platforms. For each co-user, the system integrates its interaction data on both platforms into a new array. The new array will contain all the interactive behaviors of the user on different platforms to form a comprehensive user behavior portrait.
For example, suppose that user Alice has an interaction record (e.g., click, browse, purchase) with a smart phone on platform a, and also has an interaction record with a programmed book on platform B. The system integrates these records into a new array, such as [ [ platform a, smartphone, click=5, viewTime =300, purchase=1 ], [ platform B, programming book, view=1, purchase=1 ] ].
After the interaction data integration of all the common users is completed, the computer system generates an integrated interaction array. The array is indexed by user ID, and each user corresponds to an array containing cross-platform interaction behavior. This integrated interaction array will become an input for subsequent data analysis and model debugging.
For example, the integrated interaction array may be a dictionary or similar data structure, where the keys are user IDs and the values are arrays of interactions of the user on different platforms. For example, { Alice [ [ platform a, smartphone, ], [ platform B, programming book, ], bob [.] }.
The integrated interaction array is not only the basis for the subsequent steps (e.g. the model debugging of step S30), but also directly supports the possibility of cross-platform user behavior analysis. By integrating the interaction array, the computer system can more comprehensively understand the behavior patterns of the user on different platforms, and further provide more accurate personalized services.
Step S20 plays a role in the multi-platform aggregate payment data processing flow, and decodes and integrates the encrypted interaction data into a unified interaction array, thereby providing key data support for subsequent data analysis and model application. Through the process, the computer system not only ensures the safety of the data, but also realizes seamless docking of cross-platform data, and lays a solid foundation for improving user experience and sales conversion rate.
Step S30: and repeatedly debugging the first user characteristic array, the first consumer product array, the second user characteristic array and the second consumer product array based on the array connection between the model parameter array and the integrated interaction array to obtain a first debugging user characteristic array, a first debugging consumer product array, a second debugging user characteristic array and a second debugging consumer product array.
Continuing the previous setting, platform A and platform B have uploaded the encrypted interactive data, user feature array and consumer product array, and the computer system has completed the decoding and integration of these data to obtain an integrated interactive array. Now, the system needs to use this integrated interaction array, in combination with the model parameter arrays (i.e. user feature array and consumer product array) from both platforms, to optimize these parameters by repeated debugging in order to more accurately predict the purchasing behavior of the user.
In step S30, references to "array links" or "matrix relationships" essentially refer to interactions and dependencies between user feature arrays, consumer product arrays, and integrated interaction arrays. These relationships can typically be expressed by matrix operations such as matrix multiplication, matrix decomposition, and the like. In computer systems, these operations are often used to build and train machine learning models.
Assuming that the first user feature array is U1 (dimension is m×n, where m is the number of users and n is the number of features), the first consumer product array is P1 (dimension is p×q, where P is the number of products and q is the number of product features), the integrated interaction array (interaction behavior with each product for each user) can be regarded as a sparse matrix I (dimension is m×p). A simple matrix relationship formula may be the generation of a predictive interaction matrix I x, which depends on the user feature matrix, the product feature matrix, and a weight matrix W (dimension n x q):
；
Wherein, represents a matrix multiplication,Is the transposed matrix of P1. Indicating that the predicted user interaction with the product is determined by the user characteristics, the product characteristics, and the weight relationships between them.
In the repeated debugging process, the computer system first needs to initialize the model parameters (i.e., the feature values in the user feature array and the consumer product array, and possibly the weight matrix W). The initialization may be random or based on a priori knowledge.
To evaluate the accuracy of model predictions and guide the debugging process, the system needs to define a loss function. The loss function scales the predicted interaction matrixThe difference from the actual integration interaction matrix I. Common loss functions include Mean Square Error (MSE), cross entropy loss, and the like.
Loss function formula example (mean square error):
；
Wherein Iij andAnd respectively representing the interaction values of the ith user and the jth product in the actual interaction matrix and the predicted interaction matrix.
The system adopts an iterative approach to debug model parameters to minimize the loss function. This typically involves the application of optimization algorithms such as gradient descent, stochastic gradient descent, adam optimizer, etc. In each iteration, the system calculates the gradient of the loss function with respect to the model parameters, and then updates the parameter values along the opposite direction of the gradient.
Gradient update formula example (weight matrix W for example):
；
Wherein alpha is learning rate, and controls updated step length; Is the gradient of the loss function with respect to the weight matrix W.
The system repeats the debugging process until a certain stop condition is met (e.g., the loss function value is below a certain threshold, the number of iterations reaches an upper limit, etc.). In each iteration, the system recalculates the predicted interaction matrix based on the current model parameter values and updates the loss function values. When the debugging process converges, the system obtains an optimized first debugging user feature array, a first debugging consumer product array (if feature values are adjusted in the debugging process), and an optimized weight matrix. To verify the validity of the debug results, the system may evaluate the performance of the model on a separate test dataset using leave-in methods, cross-validation, and the like.
For example, assuming that the user feature array on platform a contains information about the age, sex, historical purchase frequency, etc. of the user, the consumer product array describes the price, brand, screen size, etc. of the electronic product. The data on platform B is similar but reflects the characteristics of books and educational products. During the debugging process, the computer system may find that certain user characteristics (e.g., age) have a greater impact on the weight of certain product characteristics (e.g., price), while other user characteristics (e.g., gender) are more sensitive to other product characteristics (e.g., brand).
Through repeated debugging, the system gradually optimizes the weight values, so that the predicted interaction matrix I is more and more close to the actual integrated interaction matrix I. For example, the system may learn that young users prefer to purchase moderately priced, branded electronic products, while middle-aged users pay more attention to the practicality and cost performance of the products. At the same time, the system may also find similar patterns and laws for books and educational products on platform B.
Step S40: and performing consumption reasoning based on the first debugging user characteristic array, the first debugging consumer product array, the second debugging user characteristic array and the second debugging consumer product array to obtain a first target interaction array of the user set aiming at the first consumer product set and a second target interaction array of the user set aiming at the second consumer product set.
Continuing with the previous settings, the computer system has completed the data decoding, integration, and debugging of the model parameters from platform A and platform B. Now, the system has a first debug user feature array, a first debug consumer product array, a second debug user feature array, and a second debug consumer product array. The debugged array reflects the potential relation between the user and the product more accurately, and lays a foundation for the subsequent consumption reasoning.
Before making the consumption inference, the computer system first needs to select an appropriate model. Since consumer reasoning is essentially a predictive problem, a variety of machine learning algorithms or neural network models can be employed, such as logistic regression, support vector machines, random forests, gradient lifting trees (e.g., XGBoost, lightGBM), and deep learning models (e.g., neural networks, convolutional neural networks CNN, recurrent neural networks RNN, etc.). The specific choice of which model depends on the nature of the data, the constraints of the computational resources, and the accuracy of the reasoning that is desired.
For example, suppose the system selects a gradient-lifted tree-based model (e.g., XGBoost) because it performs well in handling classification and regression problems and is able to efficiently handle sparse data, well suited for user behavior prediction in this scenario.
After the model is selected, the computer system needs to train the model using the debugged user feature array and the consumer product array. The training process involves taking as input user features, as output, interactive behavior of the consumer product (e.g., purchase, click, etc.), and continuously adjusting model parameters by an optimization algorithm (e.g., gradient descent) to minimize prediction errors. During the training process, the system may use a cross entropy loss function (for classification problems) or a mean square error loss function (for regression problems) to measure the difference between the predicted outcome and the actual interaction behavior. Taking the cross entropy loss function as an example, the calculation formula is as follows:
；
Where N is the number of samples, yi is the actual interaction behavior (0 or 1, indicating no interaction or interacted) of the ith sample,Is the interaction probability of model prediction.
After model training is completed, the computer system can use the model to make consumption reasoning. The reasoning process is to input the characteristics of the user set into a model, and the model outputs the interaction probability or predicted value of each user to each consumer product according to the learned rule.
For example, suppose the system is making consumption inferences for an electronic product on platform A. For each user in the user set, the system inputs its characteristics (e.g., age, gender, historical purchase frequency, etc.) into the XGBoost model, which outputs the user's probability of purchasing each electronic product on platform A. These probability values constitute a probability matrix of interactions between the user and the electronic product, i.e. a first set of target interactions.
Similarly, the system may also perform consumption reasoning for books and educational supplies on platform B, generating a second set of target interactions.
The first target interaction array and the second target interaction array are direct outputs of step S40, and they have a wide application value in the data processing flow of multi-platform aggregate payment. These arrays not only reflect the potential interests of the user for a particular consumer product, but also may serve as a data base for personalized marketing systems, accurate marketing strategies, and inventory management.
Based on the high probability values in the target interaction array, the system may push consumer products that may be of interest to the user. For example, if the purchase probability of Alice for a smart phone in the first target interaction array is high, the system may push an advertisement or preferential information of the smart phone to Alice on the APP or website of platform a. The target interaction array may also help the platform formulate a more accurate marketing strategy. By analyzing the user's probability distribution of purchase of different products, the platform can identify high potential user groups and design more attractive promotions for those groups. Inventory management is an important link for e-commerce platforms. Through the target interaction array, the platform can predict which products can be welcomed by users, so that the inventory structure is adjusted in advance, and the occurrence of backlog or backlog is avoided.
Step S50: for any selected user of the set of users, determining first and second selected consumer products of the selected user's propensity in the first and second sets of consumer products based on the first and second sets of target interactions.
Step S50 aims at identifying, for any selected user of the set of users, from the respective corresponding set of consumer products, the consumer products most likely to be of interest to the user, i.e. the first selected consumer product and the second selected consumer product, based on the first set of target interactions and the second set of target interactions.
Continuing the previous setup, the computer system has completed the data processing flow from platform A (electronics) and platform B (books and educational products), including data decoding, integration, model debugging, and consumption reasoning, and has generated a first target interaction array and a second target interaction array. These arrays reflect the potential interaction tendencies of the user set for the two platform consumer products, respectively. Now, the system needs to determine, for any selected user of the set of users, the product from the two sets of consumer products that it is most likely to purchase.
Prior to performing step S50, the computer system first needs to determine one or more selected users. These users may be filtered out based on specific conditions (e.g., high value users, active users, etc.), or may be randomly selected for testing the effect of the system.
For each selected user, the computer system will view its corresponding row in the first target interaction array and the second target interaction array, respectively. Each element in these rows represents a user's propensity to interact with a different consumer product (e.g., probability of purchase).
For example, assuming that the selected user is Alice, her row of data in the first target interaction array may be as follows (taking the probability of purchase as an example):
；
One row of data in the second target interaction array may be as follows:
；
To determine a first selected consumer product that Alice prefers in a first set of consumer products (electronics) and a second selected consumer product that Alice prefers in a second set of consumer products (books), the computer system may employ a variety of strategies. The following are several possible strategies and implementations:
1. Direct maximum selection: the system directly selects the consumer product corresponding to the element with the largest probability value in each target interaction array as the selected product.
For example, in Alice's example, the system would select a smart phone as the first selected consumer product (because the probability of purchase is 0.7, which is the highest in the electronic product), and a programmed book as the second selected consumer product (because the probability of purchase is 0.5, which is the highest in the book and educational product).
2. Threshold screening and ordering: the system first sets a probability threshold (e.g., 0.4) and then screens out all products above that threshold and ranks from high to low probability values. If a plurality of products meet the conditions, selecting the product with the forefront ranking as a selected product; if no product meets the conditions, it may choose not to push or push products generated by other policies.
For example, assuming that the threshold is set to 0.4, in Alice's example, both the smartphone and the notebook in the electronic product meet the conditions, but the smartphone probability is higher and is therefore selected as the first selected consumer product; only programmed books in books and educational products satisfy the condition and are therefore selected as the second selected consumer product.
3. A number of factors are considered in combination: in some cases, the system may need to integrate multiple factors to determine a selected product, such as a product price, inventory, promotional program, etc. This typically involves introducing additional scoring mechanisms or optimization algorithms based on the target interaction array.
For example, assume that the system considers cost performance of the product in addition to the probability of purchase. For electronic products, although the purchase probability of the smart phone is highest, if the notebook computer is currently at a great discount and the cost performance is higher, the system can push the notebook computer as the first selected consumer product. Similarly, for books and educational products, if a book is programmed to be expensive although having a high probability of purchase, and another educational psychology book is more cost effective and has a lower probability of purchase, the system may select the educational psychology book as the second selected consumer product based on the composite score.
Once the first selected consumer product and the second selected consumer product of the selected user are determined, the computer system may send these push results to the user or an associated marketing platform. The pushing can be performed through various channels, such as APP pushing notification, email, short message, website personalized page display and the like.
For example, for Alice, the system may push the smart phone's advertisement or coupon information to her through platform a's APP, while pushing the programming book to her through platform B's APP or email. These push messages will be personalized based on the user's behavioral data and the system's predictive results to improve conversion and user satisfaction.
Step S50 is a final application link in the multi-platform aggregate payment data processing flow, which converts the complex data generated in the previous step into a push result with practical value. By deeply analyzing the data features in the target interaction array and combining different strategies and methods, the computer system can accurately identify the tendency products of the user in different consumer product sets and provide personalized services for the user. The process not only embodies the strong capability of the machine learning technology in terms of data processing and analysis, but also demonstrates the great potential of multi-platform data aggregation in terms of improving user experience and promoting consumption transformation. By continuously optimizing the pushing algorithm and the strategy, the computer system can further improve the pushing accuracy and the user satisfaction, and create greater value for both the E-commerce platform and the user.
As an implementation manner of step S30, in step S30, based on the array relation between the model parameter array and the integrated interaction array, repeated debugging is performed on the first user feature array, the first consumer product array, the second user feature array, and the second consumer product array, so as to obtain a first debug user feature array, a first debug consumer product array, a second debug user feature array, and a second debug consumer product array, which specifically may include:
Step S31: performing an nth round of debugging on the first user characteristic array, the first consumer product array, the second user characteristic array and the second consumer product array based on the array connection to obtain an nth round of debugged first user characteristic array, an nth round of debugged first consumer product array, an nth round of debugged second user characteristic array and an nth round of debugged second consumer product array, wherein N is a natural number greater than 0;
Step S32: obtaining an nth error value based on the first user characteristic array after the nth round of debugging, the first consumer product array after the nth round of debugging, the second user characteristic array after the nth round of debugging, the second consumer product array after the nth round of debugging and a set error calculation function;
Step S33: and if the absolute difference value of the Nth error value and the Mth error value is smaller than a reference value, determining a first user characteristic array after the Nth round of debugging, a first consumer product array after the Nth round of debugging, a second user characteristic array after the Nth round of debugging and a second consumer product array after the Nth round of debugging as the first debugging user characteristic array, the first debugging consumer product array, the second debugging user characteristic array and the second debugging consumer product array, wherein M=N-1.
Step S30 aims to more accurately reflect the potential interaction behavior between the user and the product by continuously optimizing the user feature array and the consumer product array. In step S31, the computer system directs the debugging process using the previously defined array linkages (which may be understood as mathematical or logical relationships between the model parameter arrays and the integrated interaction arrays). Such array linkages are typically embodied in the construction of machine learning models that predict the purchasing propensity of a user by learning user characteristics, product characteristics, and interactions between them.
It is assumed that platform a (electronics) and platform B (books and educational products) have uploaded the user feature array and the consumer product array and that the computer system has completed the decoding and integration of these data. Now, the system needs to adjust and optimize feature values in the user feature array and the consumer product array based on the integrated interaction array in order to more accurately predict the purchasing behavior of the user.
In the nth round of debugging, the system may employ a gradient descent method or other optimization algorithm to update the model parameters. These parameters include age, gender, historical purchase frequency, etc. in the user profile array, and price, brands, product categories, etc. in the consumer product array. The system calculates gradients and updates parameter values based on the behavior of the current model on the predictive integrated interaction array (i.e., the difference between the predicted and actual interactions). The system first calculates the gradient of the loss function with respect to each parameter. The loss function is an index for measuring the prediction accuracy of the model, and common loss functions include Mean Square Error (MSE), cross entropy loss and the like.
And updating the characteristic values in the user characteristic array and the consumer product array according to the calculated gradient. The update rule generally follows the principle of the gradient descent method, i.e. the parameter values are adjusted in the opposite direction of the gradient.
The update formula is, for example:
；
where θ represents a model parameter (e.g., user feature or product feature), α is a learning rate,Is the gradient of the loss function with respect to the parameter θ.
After the nth round of debugging, the system obtains the updated first user characteristic array, the first consumer product array, the second user characteristic array and the second consumer product array. The characteristic values in the arrays are closer to the real situation, and the potential relation between the user and the product can be reflected better.
In step S32, the computer system uses the set error calculation function to evaluate the model performance after the nth round of debugging. The error calculation function is typically defined based on the difference between the predicted and actual results, aiming to quantify the prediction accuracy of the model.
Substituting the model parameter values after the N-th debugging into a prediction model by the system to generate a prediction interaction matrix. The difference between the predicted interaction matrix and the actual integrated interaction matrix I is then calculated using the previously defined error calculation function, such as the mean square error.
Calculation formula example (mean square error):
；
Wherein, LN is the error value after the Nth round of debugging. This error value LN reflects the accuracy of the current model in predicting the user's interaction with the product. The smaller the error value, the closer the prediction result of the model is to the actual situation.
In step S33, the computer system compares the absolute difference between the nth error value and the mth error value (where m=n-1) to determine whether the debugging process is converged. If the difference is smaller than a preset reference value, the debugging process is considered to be close to the optimal solution, iteration can be stopped, and the current debugging result can be output.
The system calculates the absolute difference between the N-th error value and the N-1 th error valueAnd compares the difference with a preset reference value ϵ.
Judging conditions:；
If the above conditions are met, the debugging process is considered to be converged, and the system determines the first user characteristic array, the first consumer product array, the second user characteristic array and the second consumer product array after the N-th round of debugging as final debugging results. These debugged arrays will be used for subsequent consumer reasoning steps (step S40).
If the convergence condition is not met, the system will continue to perform the next round of debugging (i.e., n+1 rounds of debugging) and repeat the process of steps S31 to S33 until the convergence condition is met or a preset maximum number of iterations is reached.
It is assumed that after the nth round of debugging, the absolute difference between the error value LN calculated by the system and the error value LN-1 of the previous round is very small and is far smaller than the preset reference value ϵ. This indicates that the current model parameters are already very close to the optimal solution, and that continued debugging may only result in a minor performance improvement but consume more computing resources. Therefore, the system decides to stop iteration and outputs the array after the nth round of debugging as a final debugging result. The debugged arrays not only reflect the potential relationship between the user and the product, but also contain the knowledge obtained by the computer system through multiple rounds of iterative optimization. They will serve as input data for the subsequent consumption reasoning step (step S40) for generating a target interaction array and pushing the most likely consumer product of interest to the user.
By unfolding the explanation of the detailed implementation of step S30, it can be seen how the computer system optimizes the set of model parameters by iterative debugging in the data processing flow of multi-platform aggregate payment. The process involves a plurality of links such as gradient calculation, parameter updating, error calculation, convergence judgment and the like, and aims to improve the prediction accuracy of the model by continuously approaching an optimal solution. By the method, the computer system can generate a more accurate target interaction array and provide personalized services for the user, so that the user experience is improved and the consumption conversion is promoted.
As an implementation manner, the step S32 may obtain the nth error value based on the first user feature array after the nth round of debugging, the first consumer product array after the nth round of debugging, the second user feature array after the nth round of debugging, the second consumer product array after the nth round of debugging, and a set error calculation function, and the method specifically may include:
step S321: performing consumption reasoning on the first user characteristic array after the N-th round of debugging, the first consumer product array after the N-th round of debugging, the second user characteristic array after the N-th round of debugging and the second consumer product array after the N-th round of debugging to obtain an Nth first reasoning interaction array of the user set aiming at the first consumer product set and an Nth second reasoning interaction array of the user set aiming at the second consumer product set;
Step S322: and obtaining the Nth error value based on the Nth first reasoning interaction array, the Nth second reasoning interaction array and the set error calculation function.
In step S321, the computer system predicts through a trained consumption inference model (such as a machine learning algorithm or a neural network model) by using the first user feature array, the first consumer product array, the second user feature array, and the second consumer product array after the nth round of debugging as input, and generates an nth first inference interaction array of the user set for the first consumer product set and an nth second inference interaction array of the second consumer product set.
For example, assuming that user data for platform A (electronics) and platform B (books and educational products) has been N rounds of debug optimization, the computer system now has an N-th round of debugged user feature arrays and consumer product arrays. The characteristic values in the arrays are closer to the real situation, and the potential relation between the user and the product can be reflected more accurately.
In order to evaluate the effect of these debugged arrays in practical applications, the system needs to use them for consumer reasoning. Specifically, the system takes the user characteristic array after the Nth round of debugging as input, and calculates the purchase probability or interaction tendency of each user for each consumer product through a consumption reasoning model. For the electronic product of the platform A, the system generates a first reasoning interaction array which comprises predicted interaction values of the user set on a first consumer product set (electronic product); for the book and educational appliance of platform B, the system generates a second set of inferred interactions that includes predicted interactions values for the set of users for the second set of consumer products (book and educational appliance).
The consumption inference model may be an implementation of a variety of machine learning algorithms or neural networks, such as logistic regression, random forests, gradient boosting trees (e.g., XGBoost), deep Neural Networks (DNNs), etc. These models predict the purchasing behavior of a user by learning user features, product features, and interactions between them.
Taking a gradient lifting tree (XGBoost) as an example, the model integrates a prediction result by constructing a plurality of decision trees, and each tree learns a residual error on the basis of the previous tree, so that the true value is continuously approximated. In the consumption reasoning process, the XGBoost model receives the debugged user feature array as input, and predicts the interaction tendency of each user on each consumer product by traversing the decision tree nodes and splitting according to the feature values.
For platform a electronics, the first set of inference interactions may be as follows (taking the probability of purchase as an example):
；
wherein the rows represent users and the columns represent electronic products, and the element values represent the probability of the users purchasing the products.
The second set of inference interactions also has a similar structure for the books and educational products of platform B.
In step S322, the computer system evaluates the differences between the nth first inference interaction array and the second inference interaction array and the actual integration interaction array by using the set error calculation function, thereby obtaining the nth error value. This error value reflects the accuracy of the current model in predicting the user's interaction with the product.
The choice of error calculation function depends on the specific evaluation requirements and data type. In a data processing scenario of multi-platform aggregate payments, common error computation functions include Mean Square Error (MSE), cross entropy loss, and the like. These functions are able to quantify the difference between the predicted and actual results and give a specific numerical evaluation.
Taking Mean Square Error (MSE) as an example, the calculation formula is as follows:
；
Where m is the number of users, p is the number of products, Iij is the interaction value (e.g., number of purchases, number of clicks, etc.) of the ith user and the jth product in the actual integrated interaction matrix,Is the corresponding predicted interaction value in the inference interaction matrix.
In a multi-platform scenario, the system needs to calculate MSE values between the first and second inference interaction arrays and the actual integrated interaction array, respectively, and possibly weight sum them to obtain the final nth error value. If the service importance of the two platforms is different, the weight can be adjusted according to the actual situation.
The error calculation process is, for example, to assume that the system has obtained the nth first inference interaction array and the second inference interaction array and has the actual integrated interaction array as a reference for comparison. Now, the system needs to calculate the MSE values between these inferred interaction arrays and the actual interaction arrays.
For platform a electronics, the system first calculates MSE values between the first inferred interaction array and the actual integrated interaction array (for the portion of platform a). Then, for the books and educational products of platform B, the system calculates MSE values between the second inferential interaction array and the actual integrated interaction array (for the portion of platform B). If the service importance of the two platforms is the same or the weight is the same, the system can directly add the two MSE values to obtain an Nth error value; if the weights are different, a weighted summation is required according to the weights. The N error value finally obtained is used as an important index for evaluating the debugging effect of the current model. If the error value is smaller, the model has higher accuracy in predicting the interaction behavior of the user and the product; if the error value is larger, the description model has larger optimization space.
By a detailed unfolding explanation of the implementation of step S32, it can be seen how the computer system evaluates the model debugging effect by means of consumption reasoning and error calculation in the data processing flow of multi-platform aggregated payment. This process involves not only the predictive capability assessment of the machine learning model, but also the selection and application of the error calculation function. By continuously iterating the debugging and optimizing the model parameter array, the system can gradually approach the optimal solution and improve the prediction accuracy, thereby providing more personalized service for users and promoting consumption transformation.
As one implementation manner, the nth error value includes an nth first error value corresponding to the nth first inference interaction array and an nth second error value corresponding to the nth second inference interaction array; the absolute difference value of the nth error value and the mth error value is smaller than a reference value, namely the absolute difference value of the nth first error value and the mth first error value is smaller than the reference value, and the absolute difference value of the nth second error value and the mth second error value is smaller than the reference value.
In the scenario of multi-platform aggregate payments, a computer system needs to process data from different platforms simultaneously and evaluate the performance of the data in a model debugging process separately. Thus, the nth error value is not a single value, but is a composite index comprising two independent parts: an nth first error value and an nth second error value. The two error values correspond to predictive accuracy assessment on a first set of consumer products (e.g., electronic products) and a second set of consumer products (e.g., books and educational products), respectively, after the nth round of debugging.
Nth first error value: the difference between the predicted and actual interaction behavior of the user set for the first set of consumer products (platform a) is reflected. It is calculated by comparing the first inference interaction array after the nth round of debugging with the actual integration interaction array (for the part of the platform a).
Nth second error value: as such, it reflects the difference between the predicted and actual interaction behavior of the user set for the second set of consumer products (platform B). The basis for calculation is the second inference interaction array after the nth round of debugging and the actual integration interaction array (aiming at the part of the platform B).
To determine whether the debugging process is converging, the computer system needs to compare the error value of the current round (nth round) with the error value of the previous round (mth round, m=n-1). The comparison here does not simply subtract the two composite error values directly, but rather compares their respective first and second error values, respectively.
Specifically, if the absolute difference between the nth first error value and the mth first error value is smaller than a certain preset reference value, and at the same time, the absolute difference between the nth second error value and the mth second error value is also smaller than the reference value, it can be considered that after the nth debugging, the prediction accuracy of the model on both platforms is improved or at least kept stable, and the improvement or stability reaches an acceptable threshold.
Assuming that platform a is primarily selling electronic products, platform B is focused on books and educational products. The computer system has completed the N rounds of debugging and generates a first inference interaction array and a second inference interaction array after the N rounds of debugging. Now, the system needs to evaluate the accuracy of these inference interactions arrays and determine if it is necessary to proceed with the next round of debugging.
The system first calculates an nth first error value and an nth second error value, respectively. For example, for platform a electronics, the system compares the first inferred interaction array with the actual integrated interaction array (for platform a) using the Mean Square Error (MSE) as an error calculation function, resulting in the nth first error value. Similarly, for the books and educational products of platform B, the system also calculates the Nth second error value.
Next, the system compares the nth error value with the mth error value (m=n-1). During this comparison, the system checks to see if the absolute differences of the first error value and the second error value are both less than a preset reference value (e.g., 0.01). If both conditions are met, this indicates that the model has improved or maintained stability in its prediction accuracy on both platforms, and that this variation is within acceptable limits.
Based on the above comparison result, if the system determines that the debugging process has converged, the user feature array and the consumer product array after the nth round of debugging may be output as final debugging results for use in the subsequent consumption reasoning step (step S40). If it is determined that the debugging process has not converged, the system will continue to perform the next round of debugging (i.e., n+1 rounds of debugging), and repeat the processes of steps S31 to S33.
By explaining the detailed explanation of the nth error value constitution and the comparison mode of the nth error value constitution and the mth error value, the computer system can clearly understand how to evaluate the model debugging effect and judge whether the debugging process is converged in the data processing flow of the multi-platform aggregate payment. The process not only involves the selection and application of the error calculation function, but also embodies the importance of independent evaluation and comprehensive judgment of the multi-platform data. By continuously iterating the debugging and optimizing the model parameter array, the system can gradually improve the prediction accuracy, thereby providing more accurate personalized service for users.
As another implementation manner of step S30, in step S30, based on the array relation between the model parameter array and the integrated interaction array, repeated debugging is performed on the first user feature array, the first consumer product array, the second user feature array, and the second consumer product array, so as to obtain a first debug user feature array, a first debug consumer product array, a second debug user feature array, and a second debug consumer product array, which specifically may include:
Step S301: performing P-th-round debugging on the first user characteristic array, the first consumer product array, the second user characteristic array and the second consumer product array based on the array connection to obtain a first user characteristic array after P-th-round debugging, a first consumer product array after P-th-round debugging, a second user characteristic array after P-th-round debugging and a second consumer product array after P-th-round debugging; wherein P is a natural number greater than 0;
Step S302: if P is the set maximum repeated round, determining the first user characteristic array after the P-th round debugging, the first consumer product array after the P-th round debugging, the second user characteristic array after the P-th round debugging and the second consumer product array after the P-th round debugging as the first debugging user characteristic array, the first debugging consumer product array, the second debugging user characteristic array and the second debugging consumer product array.
This embodiment of step S30 provides a method of debugging the set of model parameters based on a fixed maximum repetition round. The method ensures that the debugging process is stopped when the number of iterations reaches the number by presetting a maximum iteration number P, and outputs a final debugging result.
In step S301, the computer system performs a P-th round of debugging on the first user feature array, the first consumer product array, the second user feature array, and the second consumer product array based on the previously defined array association (i.e., the mathematical or logical relationship between the model parameter array and the integrated interaction array). Here P is a natural number greater than 0, representing the current turn of the debug.
It is assumed that user data and consumer product data of the platform a (electronic products) and the platform B (books and educational products) have been primarily processed and integrated into a unified interactive array. Computer systems now need to use this data to debug feature values in user feature arrays and consumer product arrays in order to improve the accuracy of subsequent consumer reasoning.
In the P-th round of debugging, the system can update the model parameter values by adopting a gradient descent method, a random gradient descent method or other optimization algorithms. The parameters include the characteristics of age, gender, historical purchase frequency and the like in the user characteristic array, and the characteristics of price, brands, product categories and the like in the consumer product array. The system calculates gradients and updates parameter values based on the behavior of the current model on the predictive integrated interaction array (i.e., the difference between the predicted and actual interactions).
The system first calculates the gradient of the loss function with respect to each parameter. The loss function is an index for measuring the prediction accuracy of the model, and common loss functions include Mean Square Error (MSE), cross entropy loss and the like.
And updating the characteristic values in the user characteristic array and the consumer product array according to the calculated gradient. The update rules follow the principles of the selected optimization algorithm, such as gradient descent, to adjust the parameter values along the opposite direction of the gradient.
After the P-th round of debugging, the system obtains the updated first user characteristic array, the first consumer product array, the second user characteristic array and the second consumer product array. The feature values in the arrays are closer to the optimal solution, and the potential relation between the user and the product can be reflected better.
In step S302, the computer system checks whether the current debug turn P is equal to a preset maximum repetitive turn. If yes, means that the debugging process has completed all preset iteration times, and the current debugging result can be stopped and output; if not, the system will continue to perform the next round of debugging (i.e., the P+1 round of debugging).
A counter may be maintained inside the system to keep track of the current debug turn P. After each round of debugging is completed, the system compares the value of P with a preset maximum repeated round. If P is equal to the maximum repeated round, the system stops the debugging process, and the first user characteristic array, the first consumer product array, the second user characteristic array and the second consumer product array after the P-th round of debugging are determined to be final debugging results. These debugged arrays will be used for subsequent consumer reasoning steps (step S40).
Assume that the maximum number of repetition preset by the system is 10. After the 10 th round of debugging is finished, the system checks that the current round P is equal to 10, and therefore the debugging process is stopped. At this time, the system has obtained a model parameter set closer to the optimal solution through 10 rounds of iterative optimization. The arrays not only reflect the potential relationship between the user and the product, but also contain the knowledge of the computer system through multiple rounds of iterative optimization.
The system outputs these debugged arrays as final debug results and prepares them for subsequent consumption reasoning steps. Through consumption reasoning, the system can generate a target interaction array and push the most possibly interested consumption products for the user, so that user experience is improved and consumption conversion is promoted.
By explaining the further implementation of step S30 in detail, it can be seen how the computer system guides the debugging process of the model parameter values by presetting the maximum repetition in the data processing flow of the multi-platform aggregate payment. The method ensures orderly progress of the debugging process through fixed iteration times, and outputs a debugging result when the preset iteration times are reached. The method not only simplifies the control logic of the debugging process, but also can avoid the problems of overfitting and the like to a certain extent. By continuously iterating the debugging and optimizing the model parameter array, the system can gradually improve the prediction accuracy and provide more accurate personalized service for users.
As an implementation manner, the step S40, based on the first debug user feature array, the first debug consumer product array, the second debug user feature array, and the second debug consumer product array, performs consumption inference to obtain a first target interaction array of the user set for the first consumer product set and a second target interaction array of the user set for the second consumer product set, may specifically include:
step S41: based on the first debugging user characteristic array and the first debugging consumer product array, carrying out consumption reasoning of the user set for the first consumer product set to obtain the first target interaction array;
Step S42: and carrying out consumption reasoning of the user set for the second consumption product set based on the second debugging user characteristic array and the second debugging consumption product array to obtain the second target interaction array.
In step S41, the computer system performs consumption reasoning on the user set for the first consumer product set (e.g., electronic product) based on the first debug user feature array and the first debug consumer product array. The consumer inference process typically involves a trained machine learning model that predicts purchasing trends or interactions of users based on user characteristics and product characteristics.
Assuming that the platform a mainly sells the electronic product, the user feature array includes information such as age, gender, income level, historical purchase record, and the like of the user, and the consumer product array describes features such as price, brand, performance parameters, user evaluation, and the like of the electronic product. After multiple rounds of debugging, the computer system obtains a first debugging user feature array and a first debugging consumer product array, and feature values in the arrays more accurately reflect potential relations between users and products.
Now, the system needs to use these debugged arrays for consumer reasoning. It first selects an appropriate consumer inference model, such as a gradient boosting tree (XGBoost), random forest, or Deep Neural Network (DNN). Taking XGBoost as an example, the model integrates the prediction result by constructing a plurality of decision trees, each of which learns the residual error on the basis of the previous tree, so as to gradually approach the true value.
In the reasoning process, the system takes the first debugging user characteristic array as input, traverses XGBoost each decision tree in the model, and performs splitting and prediction on tree nodes according to the user characteristic values. Finally, the system outputs a first target interaction array comprising predicted interaction values (e.g., purchase probabilities) for each electronic product in the first set of consumer products for the set of users.
Similar to step S41, step S42 involves consumer reasoning about a set of users for a second set of consumer products (e.g., books and educational products). This process is also based on the commissioned user feature array and consumer product array, but the data and model may differ from product category to product category.
The platform B is assumed to sell books and educational products mainly, and the user characteristic array and the consumer product array are different from those of the platform A, so that the characteristics and the user requirements of products in different fields are reflected. After debugging, the computer system obtains a second debugging user feature array and a second debugging consumer product array.
For consumption reasoning, the system may choose the same model as in step S41 (e.g. XGBoost), or may choose a more suitable model depending on the characteristics of the different products. Whichever model is chosen, the inference process follows similar logic: and taking the debugged user characteristic array as input, and obtaining a predicted interaction value of the user set to the second consumer product set through model calculation.
By a detailed unfolding explanation of the implementation of step S40, it can be seen how the computer system predicts the interaction behavior of the user for different consumer product sets by consumption reasoning in the data processing flow of multi-platform aggregated payment. The process not only involves the selection and application of the machine learning model, but also embodies the effective utilization of the debugged data. By performing consumption reasoning for the first and second sets of consumer products, respectively, the system is able to generate two targeted interaction arrays that provide important data support for subsequent personalized pushing and marketing strategies. By continuously optimizing the consumption reasoning model and the debugging process, the computer system can gradually improve the prediction accuracy and provide more accurate personalized services for users, thereby enhancing user experience and promoting consumption conversion.
As an embodiment, the step S50, for any selected user in the user set, determining, based on the first target interaction array and the second target interaction array, a first selected consumer product and a second selected consumer product that are prone to the selected user in the first consumer product set and the second consumer product set, may specifically include:
Step S51: determining, in the first target interaction array, first target interaction characterization information for the first set of consumer products for the selected user;
Step S52: determining, in the second set of target interactions, second target interaction characterization information for the selected user for the second set of consumer products;
Step S53: performing numerical descending arrangement on the characteristic values of each dimension of the first target interaction characterization information to obtain a first characterization sequence; performing numerical descending arrangement on the characteristic values of each dimension of the second target interaction characterization information to obtain a second characterization sequence;
Step S54: determining a first consumer product corresponding to a first characteristic value in the first characterization sequence as the first selected consumer product; and determining a second consumer product corresponding to the first characteristic value in the second characterization sequence as the second selected consumer product.
In step S51, the computer system first needs to find interaction characterization information of the selected user for the first set of consumer products (e.g., electronic products) in the first target interaction array. Such characterization information is typically in the form of vectors, wherein the characteristic value of each dimension represents the propensity for interaction (e.g., probability of purchase, click rate, etc.) between the user and the corresponding consumer product.
For example, assuming that the selected user is Alice, her first target interaction array on platform A (electronic product sales platform) has been generated by step S40. The array contains the predicted interaction values of Alice for all electronic products on platform a. Now, the system needs to find interactive characterization information corresponding to Alice in the array.
The first target interaction array may be as follows (taking the purchase probability as an example, the following example is latex format code):
[
Text { first target interaction array } =
\begin{bmatrix}
\Text { user 1} & \text { smart phone } & \text { notebook computer } & \text { smart watch } & \ cdots \
\text{Alice}&0.75&0.50&0.25&\cdots \
Text { user 2} & \ vdots & \ vdots & \ vdots & \ ddots \
\end{bmatrix}
]
The system locates to her interaction characterization information, i.e., vector 0.75, 0.50, 0.25, by retrieving the user ID (e.g., alice). This vector is the first target interaction characterization information for Alice for the first set of consumer products, reflecting the predicted probability that Alice will purchase a different electronic product.
Similar to step S51, step S52 requires the computer system to look up in the second set of target interactions information characterizing interactions of the selected user with respect to the second set of consumer products (e.g., books and educational products). Such characterizing information is also present in the form of vectors representing the propensity of the user to interact with the corresponding consumer product.
Continuing with Alice as an example, her second set of target interactions on platform B (book and educational product sales platform) has also been generated by step S40. Now, the system needs to find interactive characterization information corresponding to Alice in the array.
The second target interaction array may be as follows (again taking the probability of purchase as an example):
[
text { second target interaction array } =
\begin{bmatrix}
\Text { user 1} & \text { programming book } & \text { educational psychology } & \text { mathematical teaching material } & \ cdots \
\text{Alice}&0.60&0.45&0.30&\cdots \
Text { user 2} & \ vdots & \ vdots & \ vdots & \ ddots \
\end{bmatrix}
]
The system retrieves the user ID (Alice) in the same way to locate her interaction characterization information, i.e., vector 0.60, 0.45, 0.30. This vector is the second target interaction characterization information for Alice for the second set of consumer products, reflecting the predicted probability that Alice will purchase different books and educational products.
In step S53, the computer system needs to perform numerical descending order of the feature values of each dimension in the first target interaction characterization information and the second target interaction characterization information, so as to generate two characterization sequences. The two sequences reflect the purchase propensity ordering of the selected user in different consumer product collections, respectively.
For Alice's first target interaction characterization information [0.75, 0.50, 0.25. ], the system ranks its eigenvalues in descending order to obtain a first characterization sequence: [ Smart phone, notebook computer, smart watch, ]. This sequence shows that in electronic products Alice is most likely buying a smartphone, next to a notebook, next to a smartwatch, etc.
Likewise, for Alice's second target interaction characterization information [0.60, 0.45, 0.30. ], the system also ranks its eigenvalues in descending order to obtain a second characterization sequence: [ Programming books, educational psychology, math teaching materials, ]. This sequence shows that in books and educational products, alice is most likely to purchase a programmed book, followed by an educational psychology book, followed again by a mathematical textbook, etc.
Finally, in step S54, the computer system determines a first selected consumer product and a second selected consumer product for which the selected user is prone based on the generated characterization sequence. Specifically, the system determines a first consumer product corresponding to a first characteristic value in a first sequence of characterizations as a first selected consumer product and determines a second consumer product corresponding to the first characteristic value in a second sequence of characterizations as a second selected consumer product.
For Alice, her first selected consumer product is a smartphone (because the smartphone ranks first in the first characterization sequence) and the second selected consumer product is a programming book (because the programming book ranks first in the second characterization sequence).
While the above embodiments provide a straightforward and efficient method of determining a selected consumer product, in practical applications, the computer system may further optimize this process according to specific needs. The following are some possible optimization strategies:
1. Threshold value screening: the system may set a purchase probability threshold (e.g., 0.5) before generating the characterization sequence. Only products with a predicted purchase probability above this threshold will be taken into account for the characterization sequence. Thus, products with extremely low predicted purchase probability can be eliminated, and the pushing accuracy and relevance are improved.
2. A number of factors are considered in combination: in determining the selected consumer product, the system may integrate other factors, such as product price, inventory, promotional program, etc., in addition to purchasing probability. These factors may be quantified by additional scoring mechanisms or optimization algorithms and used in conjunction with the probability of purchase as a basis for determining the selected consumer product.
3. Personalized push policy: the system may employ different push strategies for different types of users and products. For example, for high value users or active users, the system may provide more personalized and accurate pushing; for new or promotional products, the system may give higher push weights.
4. Real-time update and feedback loop: with the continued accumulation of user behavioral data, the system may update the first target interaction array and the second target interaction array in real-time and redetermine the selected consumer product based on the new data. Meanwhile, the system can collect feedback (such as clicking, purchasing, evaluating and the like) of the pushing result from the user, and the feedback is used as an important basis for optimizing the pushing algorithm.
5. Cross-platform collaborative pushing: in the scenario of multi-platform aggregate payments, data between different platforms may complement and augment each other. The system can utilize the data integration capability of the cross-platform to provide more comprehensive and accurate service for users. For example, after a user purchases a smart phone on platform a, the system may push accessories or application books, etc. associated with the smart phone on platform B.
By a detailed unfolding explanation of the embodiment of step S50, it can be seen how the computer system determines consumer products of selected user tendencies by consumer reasoning and token ordering in the data processing flow of multi-platform aggregated payment. The process not only involves basic operations such as data retrieval, sorting and selection, but also embodies a deep understanding of user behavior patterns and product characteristics. By continuously optimizing the pushing algorithm and the strategy, the computer system can provide more personalized and accurate service for the user, thereby improving the user experience and promoting the consumption conversion. Meanwhile, the cross-platform data integration and collaborative pushing also create greater value for both the e-commerce platform and the user.
As an implementation manner, the step S20 of decoding and integrating the first security coding array and the second security coding array to obtain an integrated interaction array of the first interaction array and the second interaction array may specifically include:
step S21: performing restoration mapping on the first security coding array and the second security coding array to obtain the first interaction array and the second interaction array;
Step S22: and integrating the first interaction array and the second interaction array based on the user ID in the user set to obtain the integrated interaction array.
In step S21, the computer system performs a restoration mapping on the first security coding array and the second security coding array uploaded from the platform a and the platform B to restore the original interaction data, i.e. the first interaction array and the second interaction array. This process typically involves the application of a decryption algorithm to ensure that only authorized systems can access and decode such data.
For example, assume that, in order to protect user privacy, the platform a and the platform B respectively perform encryption processing on the collected user and product interaction data. The encrypted data is uploaded to the computer system in the form of a secure code array. Now, the system needs to restore these encrypted data to the original interaction array.
First, the computer system needs to know the specific encryption algorithm used by platform a and platform B when uploading data. These algorithms may be symmetric encryption algorithms (e.g., AES) or asymmetric encryption algorithms (e.g., RSA). The system selects a corresponding decryption algorithm based on the type of encryption algorithm. For each security encoding array, the system traverses each element in the array, decrypting it using a decryption algorithm. The decryption process may require the participation of keys that have been distributed to the system through a secure channel prior to data transmission.
The decrypted data may not be in the form of a directly available interactive array, but may require further processing to restore the original interactive data. This process may include operations such as conversion of data formats, mapping of fields, and the like. For example, the decrypted data may be a JSON object containing multiple fields that the system needs to map to the corresponding interactive array columns.
For example, assume that one element in the first security encoding array uploaded by platform a is decrypted to obtain the following JSON object:
json
{
"user_id": "123",
"product_id": "A001",
"interaction_type": "click",
"timestamp": "2023-04-01T12:00:00Z"
}
The system needs to map this JSON object to a row in the first interaction array with user_id and product_id as row indices (or extra columns), interaction_type and timestamp as descriptive information of the interaction behavior (or extra columns). If the interaction array only focuses on the number of clicks, then the record of interaction_type as "click" may be converted to a click number plus 1 operation.
After the restore mapping, the first interaction array may be as follows (simplified representation, containing only user ID and product ID):
[
text { first interaction array } =
\begin{bmatrix}
\text{user_id}&\text{product_id} \
123&A001 \
\vdots&\vdots
\end{bmatrix}
]
Similarly, the second security coding array uploaded by the platform B is also subjected to the same decryption and restoration mapping process to obtain a second interaction array.
In step S22, the computer system needs to integrate the first interaction array and the second interaction array based on the user IDs in the user set, so as to generate an integrated interaction array containing cross-platform interaction data. This process ensures that each user has a unique record in the integrated interaction array and contains all the interactions of that user on different platforms.
First, the system traverses all user IDs in the first interaction array and the second interaction array to find common users present in both arrays. These co-users are the basis for cross-platform interaction data analysis. For each co-user, the system merges its interaction data in the first interaction array and the second interaction array into the same row in the integrated interaction array. If the user does not have interaction data on a platform, the relevant columns for that platform may be populated with default values (e.g., 0 or null) in the integrated interaction array.
Multiple interactions of the user with the same product on the same platform may be encountered during the merging process. The system needs to process the repeated interactions according to actual requirements, such as accumulating the number of clicks, taking the latest interaction record, and the like.
Continuing with Alice as an example, assume that she has an interaction record with the smartphone on platform a and an interaction record with the programming book on platform B. After step S21, the system has obtained a first interaction array and a second interaction array containing Alice interaction data.
Now, the system needs to merge the interaction data in both arrays into an integrated interaction array based on Alice's user ID. The integrated interaction array may include a user ID, a platform A product ID, a platform B product ID, and corresponding interaction description information (e.g., number of clicks, duration of browsing, etc.). If the interaction description information is not directly available, the system may need to be converted or calculated according to the interaction type.
If Alice has multiple click records on the smart phone on platform a, the system may accumulate these records for the click sequence of the smart phone in the integrated interaction array. Similarly, if Alice has both browse and purchase interactions on platform B for a programmed book, the system may record corresponding values for the browse duration and purchase times columns, respectively.
By explaining the implementation of step S20 in detail, it can be seen how the computer system converts the security code array into the original interaction array by decryption and restoration mapping in the data processing flow of multi-platform aggregate payment, and integrates these interaction arrays into a unified integrated interaction array based on the user ID. The process not only ensures the safety of the data, but also provides comprehensive user behavior data support for subsequent model debugging and consumption reasoning through cross-platform data integration. By continuously optimizing the decryption algorithm and the integration strategy, the computer system can process the data of multi-platform aggregate payment more efficiently, and more accurate and personalized service experience is provided for users.
As an embodiment, the method may further include:
Step S60: combining the first selected consumer product and the second selected consumer product to obtain a target combined consumer product;
Step S70: the target consolidated consumer product is sent to the selected user.
In step S60, the computer system performs a merge process on the first selected consumer product and the second selected consumer product determined in step S50 to generate a target merged consumer product. This process may involve simple product list consolidation, or may require more complex consolidation logic design depending on the characteristics of the product, user preferences, or marketing strategies.
For example, assuming that the selected user is Alice, the system determines that Alice 'S first selected consumer product on platform a is a smart phone and that Alice' S second selected consumer product on platform B is a programmed book, via the analysis of step S50. The system now requires the merging of these two selected consumer products.
In the simplest case, the system can send the smartphone and the programming book directly to Alice as two separate products without physical consolidation. In practice, however, such simple list presentation may not be sufficient to attract the attention of the user or to motivate the desire to purchase. To enhance the push effect, the system may attempt to intelligently merge the two selected consumer products. For example, if the system detects that the programming book is a tutorial about smartphone development, it may push the smartphone and programming book to Alice as a "learn and develop suite". This package may contain additional benefits such as smart phones, programming books, and possibly online course coupons or learning community membership. Another possible way of merging is dynamic packing. The system dynamically generates a series of preferential packages for the user to select according to the information such as the current product inventory, the promotion, the user purchase history and the like. For example, the system may create a "digital living gift package" that contains a smart phone, programming books, and a popular game application, and push it to Alice at a preferential price.
In the case of smart merge, the system can push to Alice a "smart phone development study package" that contains her selected smart phone and programming book, while also giving coupons for online programming courses. Such pushing not only meets Alice's need for smart phones and programming knowledge, but also increases the attractiveness of the purchase through additional benefits.
In step S70, the computer system will send the push information for the target consolidated consumer product to the selected user via the appropriate channel. These channels may include email, text messages, APP push notifications, social media messages, etc., with the specific choice depending on the user's preferences and platform characteristics.
When the system sends push information, the individuation degree of the information is ensured. This means that the message content should be customized according to the user's personal information, purchase history, browsing behavior, etc., to improve the relevance and attractiveness of the message. To maximize the push effect, the system may attempt to send push information to the user through multiple channels. For example, the system may send an email to the user's registered mailbox at the same time and alert the user to view the push content via the APP push notification. After sending the push information, the system should track the response situation of the user and collect the feedback opinion of the user. Such information is critical to evaluating push effects, optimizing push algorithms, and enhancing user experience.
Assume that the system decides to send push information of "smart phone development study Package" to Alice through both email and APP push notification. The email may contain detailed package description, product pictures, preferential prices, and user ratings, while the APP push notification may be a concise title and link that directs the user to jump directly to the purchase page. After Alice receives the information, the Alice can make viewing and purchasing decisions according to the needs and interests of Alice.
By a detailed unfolding explanation of steps S60 and S70, it can be seen how the computer system further improves the user experience and promotes the conversion of consumption by merging selected consumer products and sending personalized push information in the data processing flow of multi-platform aggregated payment. The two steps not only embody the deep understanding and intelligent analysis capability of the system to the user behavior, but also demonstrate the flexibility and innovation of the system in the aspects of marketing strategy execution and user interaction. By continuously optimizing the push algorithm and marketing strategy, the computer system can provide more accurate and personalized service experience for users, thereby enhancing the viscosity of the users and promoting the service growth.
Fig. 3 is a schematic structural diagram of a computer system according to an embodiment of the application. As shown in fig. 3, the computer system 1000 may include: processor 1001, network interface 1004, and memory 1005, and in addition, the computer system 1000 may further include: a user interface 1003, and at least one communication bus 1002. Wherein the communication bus 1002 is used to enable connected communication between these components. The user interface 1003 may include a Display (Display), a Keyboard (Keyboard), and the optional user interface 1003 may further include a standard wired interface, a wireless interface, among others. The network interface 1004 may optionally include a standard wired interface, a wireless interface (e.g., WI-FI interface). The memory 1005 may be a high-speed RAM memory or a nonvolatile memory (non-volatile memory), such as at least one magnetic disk memory. The memory 1005 may also optionally be at least one storage device remote from the processor 1001. As shown in fig. 3, an operating system, a network communication module, a user interface module, and a device control application may be included in the memory 1005, which is a type of computer-readable storage medium.
In the computer system 1000 shown in FIG. 3, the network interface 1004 may provide network communication functions; while user interface 1003 is primarily used as an interface to provide input; and the processor 1001 may be used to invoke the device control application stored in the memory 1005 to implement the method provided in the above embodiment.
It should be understood that the computer system 1000 described in the embodiments of the present application may perform the foregoing description of the data processing method for multi-platform aggregate payment in the corresponding embodiment of fig. 2, which is not repeated herein. In addition, the description of the beneficial effects of the same method is omitted.
The terms first, second and the like in the description and in the claims and drawings of embodiments of the application are used for distinguishing between different elements and not necessarily for describing a particular sequential or chronological order. Furthermore, the term "include" and any variations thereof is intended to cover a non-exclusive inclusion. For example, a process, method, article, or apparatus that comprises a list of steps or elements is not limited to only those listed or inherent to such process, method, article, or apparatus but may optionally include other steps or elements not listed.
The embodiment of the present application further provides a computer program product, which includes a computer program/instruction, where the computer program/instruction when executed by a processor implements the description of the data processing method for multi-platform aggregate payment in the foregoing corresponding embodiment of fig. 2, and therefore, a detailed description will not be given here. In addition, the description of the beneficial effects of the same method is omitted. For technical details not disclosed in the embodiments of the computer program product according to the present application, reference is made to the description of the method embodiments according to the present application.
Those of ordinary skill in the art will appreciate that the elements and algorithm steps described in connection with the embodiments disclosed herein may be embodied in electronic hardware, in computer software, or in a combination of the two, and that the elements and steps of the examples have been generally described in terms of function in the foregoing description to clearly illustrate the interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.