An ai-based player churn early warning and intervention method and system

Abstract

The application discloses an AI-based player loss early warning and intervention method and system, and specifically comprises the following steps: data cleaning, conversion and fusion of player portrait data to form a unified data view; based on the unified data view, a player behavior space-time graph is constructed, a graph propagation model is developed, and graph features are output; based on the graph features, the player stage is divided into a novice period, a growth period and a mature period according to a hidden Markov model, and a stage-specific recall strategy library is constructed through the player stage; player operation sequences are collected to construct an operation failure mode library; based on the player stage, the operation failure mode library and the graph features, a deep learning model is used to predict the loss probability of the player; based on the loss probability, the player stage and the operation failure mode library, a strategy is selected and adjusted from the stage-specific recall strategy library to generate an individualized recall strategy. The application realizes individualized recall and effectively improves the player loss prediction accuracy and intervention effect.

Description

Technical Field

[0001] This invention relates to the field of artificial intelligence technology, and in particular to an AI-based method and system for player churn early warning and intervention. Background Technology

[0002] In today's booming gaming industry, player churn has become a key factor affecting the effectiveness of game operations. Traditional player churn prediction models mainly rely on simple statistical methods or rule engines, which have many significant shortcomings and are difficult to meet the complex needs of modern game operations.

[0003] First, traditional models often use fixed rules and simple statistical indicators to assess player churn risk, failing to fully consider the complex changes in player behavior at different game stages and in different social environments. For example, players may frequently fail during the beginner phase due to unfamiliarity with controls, but as they progress and their skills improve, their failure patterns will change. Traditional models struggle to dynamically track these changes, resulting in a superficial understanding of player behavior and an inability to accurately predict churn risk.

[0004] Secondly, traditional models, when predicting player churn, typically consider player attributes, social relationships, in-game behavior sequences, and time factors in isolation. However, these factors are interconnected and mutually influential in reality. For example, a player's social relationships may affect their engagement and retention rate in the game, while changes in in-game behavior sequences may be closely related to social interactions. Traditional models fail to organically integrate these factors, leading to a significant reduction in prediction accuracy and hindering the effectiveness of intervention measures.

[0005] Furthermore, due to the low predictive accuracy of traditional models, intervention strategies based on them often lack specificity. For example, traditional models might employ the same recall strategy—such as simply pushing promotional activities—for players who churned due to social loneliness and those who churned due to excessive game difficulty. This fails to address the core issues faced by players, resulting in poor intervention effectiveness and low player recall rates. Simultaneously, existing systems struggle to develop precise recall strategies tailored to the individual characteristics and reasons for churn of each player when dealing with a large number of players. Different players have different needs, preferences, and reasons for churn in the game. A uniform recall strategy cannot meet personalized needs, not only wasting resources but also potentially lowering the user experience due to strategies that do not meet player expectations, further exacerbating player churn.

[0006] Finally, during game operation, a large amount of heterogeneous game data from multiple sources is generated. However, existing technologies cannot effectively integrate and utilize this data. Different types of data are stored in different systems with significant differences in format and structure. The lack of a unified data processing and analysis framework results in a large amount of valuable information being buried, failing to provide comprehensive and accurate data support for player churn prediction and intervention.

[0007] Furthermore, existing models are insufficient in capturing the complex patterns and spatiotemporal dynamics of player behavior. Player behavior in games is highly complex and uncertain, influenced not only by their own skill level and emotional state but also closely related to factors such as the in-game social environment and task design. Simultaneously, player behavior changes continuously over time, exhibiting significant spatiotemporal dynamics. Existing models struggle to accurately model these complex patterns and dynamic changes, leading to inaccurate understanding of player churn patterns and failing to provide a reliable basis for operational decisions. Summary of the Invention

[0008] The purpose of this invention is to provide an AI-based method and system for player churn early warning and intervention, which enables personalized recall and effectively improves the accuracy of player churn prediction and intervention effect, thereby solving at least one of the aforementioned problems in the prior art.

[0009] Firstly, the present invention provides an AI-based method for player churn early warning and intervention, the method specifically including: Collect player profile data, clean, transform, and merge the player profile data to form a unified data view; Based on a unified data view, a spatiotemporal graph of player behavior is constructed, a graph propagation model is developed, and graph features are output. Based on graph features, the player stages are divided into novice, growth and maturity stages according to the Hidden Markov Model, and a stage-specific recall strategy library is constructed based on the player stages. Collect player action sequences and build an action failure mode library to identify stuck points and typical failure modes of accidental actions; Based on player stage, operation failure pattern library and graph features, deep learning models are used to learn the spatiotemporal patterns and churn rules of player behavior, and predict the probability of player churn. Based on a library of churn probability, player stage, and operation failure patterns, strategies are selected and adjusted from a stage-specific recall strategy library according to individual player characteristics and reasons for churn, generating personalized recall strategies.

[0010] Secondly, the present invention provides an AI-based player churn early warning and intervention system, the system specifically comprising: The data processing module is used to collect player profile data, clean, transform, and merge the player profile data to form a unified data view; The graph feature module is used to construct a spatiotemporal graph of player behavior based on a unified data view, develop a graph propagation model, and output graph features. The player stage module is used to divide the player stage into novice, growth and maturity stages based on graph features and hidden Markov models, and to build a stage-specific recall strategy library based on the player stage. The player operation module is used to collect player operation sequences and build an operation failure mode library to identify stuck points and typical failure modes of accidental operation. The churn prediction module is used to predict the probability of player churn by learning the spatiotemporal patterns and churn rules of player behavior using a deep learning model based on player stage, operation failure pattern library and graph features. The recall strategy module is used to select and adjust strategies from a stage-specific recall strategy library based on churn probability, player stage, and operation failure mode library, according to individual player characteristics and reasons for churn, to generate personalized recall strategies.

[0011] Thirdly, the present invention provides a computer device, including: a memory and a processor, and a computer program stored in the memory, wherein when the computer program is executed on the processor, it implements the AI-based player churn warning and intervention method as described in any of the above methods.

[0012] Fourthly, the present invention provides a computer-readable storage medium having a computer program stored thereon, wherein the computer program, when executed by a processor, implements the AI-based player churn warning and intervention method as described in any of the above methods.

[0013] Compared with the prior art, the present invention has at least one of the following technical effects: 1. This invention enables personalized recall, effectively improving the accuracy of player churn prediction and the effectiveness of intervention.

[0014] 2. This invention constructs a graph propagation model, which effectively simulates the propagation path of loss risk and dynamically adjusts the propagation intensity by introducing an attention mechanism, thereby improving the accuracy of the model.

[0015] 3. This invention calculates risk propagation values ​​and identifies typical patterns based on a graph propagation model, effectively mining the characteristics of churn in social circles and task chains, and providing key evidence for churn analysis.

[0016] 4. This invention utilizes multiple types of features to construct a deep learning model to predict churn probability, effectively integrating multiple features to capture player behavior spatiotemporal patterns and churn patterns, thereby improving prediction accuracy.

[0017] 5. This invention generates personalized recall strategies based on multiple factors, effectively formulating precise strategies according to individual player characteristics and reasons for churn, thereby improving resource utilization efficiency and user experience. Attached Figure Description

[0018] To more clearly illustrate the technical solutions in the embodiments of this application, the drawings used in the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0019] Figure 1 This is a flowchart illustrating an AI-based player churn warning and intervention method according to an embodiment of the present invention; Figure 2 This is a schematic diagram of the structure of an AI-based player churn early warning and intervention system provided in an embodiment of the present invention; Figure 3 This is a schematic diagram of the structure of a computer device provided in an embodiment of the present invention. Detailed Implementation

[0020] In the following description, specific details such as particular system architectures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that this application may also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known systems, apparatuses, circuits, and methods have been omitted so as not to obscure the description of this application with unnecessary detail.

[0021] It should be understood that, when used in this application specification and the appended claims, the term "comprising" indicates the presence of the described features, integrals, steps, operations, elements and / or components, but does not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or a collection thereof.

[0022] It should also be understood that the term “and / or” as used in this application specification and the appended claims means any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.

[0023] As used in this application specification and the appended claims, the term "if" may be interpreted, depending on the context, as "when," "once," "in response to determination," or "in response to detection." Similarly, the phrase "if determined" or "if detected [the described condition or event]" may be interpreted, depending on the context, as meaning "once determined," "in response to determination," "once detected [the described condition or event]," or "in response to detection [the described condition or event]."

[0024] Furthermore, in the description of this application and the appended claims, the terms "first," "second," "third," etc., are used only to distinguish descriptions and should not be construed as indicating or implying relative importance.

[0025] References to "one embodiment" or "some embodiments" as described in this specification mean that one or more embodiments of this application include a specific feature, structure, or characteristic described in connection with that embodiment. Therefore, the phrases "in one embodiment," "in some embodiments," "in other embodiments," "in still other embodiments," etc., appearing in different parts of this specification do not necessarily refer to the same embodiment, but rather mean "one or more, but not all, embodiments," unless otherwise specifically emphasized. The terms "comprising," "including," "having," and variations thereof mean "including but not limited to," unless otherwise specifically emphasized.

[0026] In this application embodiment, the entity executing the process includes a terminal device. This terminal device includes, but is not limited to, devices capable of executing the methods disclosed in this application, such as servers, computers, smartphones, and tablets. Figure 1 A flowchart illustrating an AI-based player churn warning and intervention method according to an embodiment of the present invention is shown below in detail: S101 collects player profile data, cleans, transforms, and merges the player profile data to form a unified data view.

[0027] In this embodiment, player profile data is collected through multiple channels, including game server logs, client feedback interfaces, and third-party social platform authorization interfaces. Game server logs record various player actions within the game, such as login time, participation in game levels, and item usage records; client feedback interfaces collect feedback information actively submitted by players, including evaluations of game difficulty and suggestions for game features; and third-party social platform authorization interfaces obtain some publicly available information about players on social platforms, such as basic information like age, gender, and location, as well as social relationship network data.

[0028] Missing values ​​in the collected player profile data are identified and processed. Statistical methods and business rules are used to detect outliers and check for duplicate records, followed by data cleaning. Then, the collected data in different formats is converted into a unified format, units are standardized, and the player profile data is classified and coded.

[0029] The transformed player profile data is then linked and merged from different data sources, using player ID as the key field. The data is integrated from multiple dimensions, including not only basic player information and gaming behavior data, but also social relationship data, spending data, and more. Data consistency is verified during the fusion process. If inconsistencies are found, they are assessed and corrected based on factors such as the reliability of the data sources and their chronological order, ensuring the consistency of the merged data.

[0030] Through the above steps, the player profile data is collected, cleaned, transformed, and integrated to form a unified data view, providing a high-quality data foundation for subsequent methods.

[0031] S102, based on a unified data view, constructs a spatiotemporal graph of player behavior, develops a graph propagation model, and outputs graph features.

[0032] In this embodiment, key elements required for constructing a spatiotemporal graph of player behavior are extracted from a unified data view. First, basic player information is compiled, including player ID, registration time, and device type; this information serves as fixed attributes for player nodes. Next, various behavioral data of players in the game are extracted, such as login time, game duration, game levels participated in, and items used. This behavioral data will be used to construct dynamic behavioral information of players during the game process. Simultaneously, social relationship data of players is obtained from the data, such as friend lists, team records, and frequency of social interactions, to clarify the social connections between players. Furthermore, time dimension information needs to be extracted, arranging player behaviors in chronological order to provide a timeline basis for subsequent construction of the spatiotemporal graph.

[0033] Players are treated as nodes in the graph, with each node containing basic information and dynamic behavioral characteristics within the game. Social relationships between players are represented by edges. If player A and player B are friends, an edge is created between their corresponding nodes, with attributes recording the time they became friends, interaction frequency, etc. Simultaneously, edges are constructed based on player behavior in the game. For example, if player A and player B jointly participated in a game level, an edge is also created between these two nodes, with attributes recording the time of participation and performance within that level. In this way, player nodes and edges are organized according to temporal and spatial (game scene) relationships, forming a preliminary framework for a spatiotemporal graph of player behavior.

[0034] In terms of time, player actions are precisely labeled according to their login time and the time of their actions, arranged in a chronological sequence. In terms of space, player actions are located within specific game spaces, considering different game scenes and levels. For example, if player A performs actions such as moving or attacking in level 1, these actions are associated with the specific game space of level 1, clearly showing the correspondence between player actions and game spaces in the spatiotemporal graph. By refining the time and space dimensions, the spatiotemporal graph of player behavior can more accurately reflect the player's behavioral trajectory and social interactions within the game.

[0035] The core logic of the graph propagation model is designed to simulate the propagation and influence of player behavior and social relationships within the graph. This model considers both direct interactions and indirect influences between player nodes. For example, an active player might influence the game behavior of their friends through social relationships, making their friends more active as well. The model defines propagation rules, such as how player node behavioral characteristics (e.g., game duration, level completion status) can be passed to adjacent nodes via edges. The strength of the propagation can be adjusted based on edge attributes (e.g., interaction frequency, number of times they participated in levels together). The model also considers the impact of time on propagation; the effect of propagation may gradually weaken over time. For example, the impact of player A's high activity on player B on a particular day might gradually decrease after a few days. By continuously adjusting and optimizing the propagation rules, the model can more accurately simulate the dynamic changes of player behavior and social relationships within the graph.

[0036] The graph propagation model is trained using a subset of data from a unified data view as the training set. During training, the spatiotemporal graph of player behavior is input into the model. Based on known player behavior and social relationship data, the model's parameters are adjusted to accurately predict the propagation and changes in player behavior. For example, the propagation rules and parameter settings are optimized by observing changes in the behavioral characteristics of player nodes in the training set at different time points and how these changes propagate to other nodes through edges. Simultaneously, the trained model is validated using a validation set to evaluate its accuracy and generalization ability. If the model's performance on the validation set is unsatisfactory, the model's parameters and structure are further adjusted until the model achieves satisfactory predictive results.

[0037] The trained and optimized graph propagation model can perform in-depth analysis of the spatiotemporal graph of player behavior and output various graph features. These features include player node characteristics, such as player activity characteristics (average daily game time, login frequency, etc.), social influence characteristics (number of friends, degree of influence on friends' behavior, etc.), and game skill characteristics (level completion rate, proficiency in using items, etc.). It also outputs edge characteristics, such as the strength of social relationships (interaction frequency, shared game time, etc.) and behavioral association characteristics (types of shared levels, cooperation in shared levels, etc.). Furthermore, it can output global features of the entire graph, such as graph density (the tightness of connections between players) and community structure characteristics (characteristics of player groups formed within the game). These graph features will provide important basis for subsequent player churn prediction and personalized recall strategy development.

[0038] S103, based on graph features, divides the player stage into novice, growth and maturity stages according to the Hidden Markov Model, and builds a stage-specific recall strategy library based on the player stage.

[0039] In this embodiment, key features closely related to player game progress and behavior patterns are selected from the graph features constructed and output based on a unified data view. These features include, but are not limited to, player login frequency, game duration distribution, level completion status, item usage frequency, and social interaction activity. These features are standardized to unify values ​​with different dimensions and ranges to a suitable scale for subsequent analysis. Simultaneously, based on general understanding and practical business experience in the gaming industry, three latent states of the Hidden Markov Model are predefined, corresponding to the novice stage, growth stage, and maturity stage, respectively. The beginner stage is set when players first enter the game, are unfamiliar with the rules and controls, may log in frequently but have relatively short playtimes, mainly engage in low-level activities, use items infrequently and may be unfamiliar with them, and have limited social interaction. The growth stage is set when players have mastered the basic rules and controls, their login frequency gradually stabilizes and increases, their playtime extends, they begin to challenge intermediate levels, their item usage frequency increases and they become more proficient, and their social interaction gradually increases. The mature stage is set when players are very familiar with the game, their login frequency is stable and high, their playtime may vary depending on individual habits but is generally longer, they can easily pass advanced levels, their item usage is at a high level and they can use it flexibly, their social interaction is active and they may form a stable social circle.

[0040] A Hidden Markov Model (HMM) is constructed using the processed map features as the observation sequence. The HMM comprises three key parameters: the initial state probability distribution, the state transition probability matrix, and the observation probability matrix. The initial state probability distribution represents the probability that a player is in the novice, growth, or mature stage at the start of the game. Based on statistical analysis of a large amount of initial behavior data from new players, the initial probability for the novice stage is typically set relatively high. The state transition probability matrix describes the probability of a player transitioning from one stage to another, such as the probability of transitioning from the novice stage to the growth stage, from the growth stage to the mature stage, and the probability of remaining in each stage. These probabilities are determined by analyzing the transitions between different stages in historical player data. The observation probability matrix represents the probability of a specific observed feature appearing in each state. For example, in the novice stage, the probability of observed features such as lower login frequency and shorter game time is higher. This probability is calculated by statistically analyzing the frequency of different observed features in each state.

[0041] A Hidden Markov Model (HMM) is trained using extensive historical player graph feature data and known actual player stage information (which can be determined through manual annotation or by comprehensively assessing players' long-term behavior). During training, the parameters of the initial state probability distribution, state transition probability matrix, and observation probability matrix are continuously adjusted to maximize the model's accuracy in predicting player stages based on observed features. After training, the current player's graph features are input into the trained HMM. Based on the observed features and the learned parameters, the model calculates the probability that the player is in one of three stages: novice, growth, or maturity. The stage with the highest probability is selected as the player's current stage, thus achieving accurate stage classification.

[0042] This analysis delves into the characteristics and needs of players at each of the three player stages: beginner, growth, and mature. Beginner players may have a strong need for game guidance and explanations of basic rules, and are prone to churn due to difficulties in controls or unclear rules. Therefore, re-engagement strategies should focus on providing detailed beginner tutorials, easy-to-understand operation tips, and exclusive rewards for beginners (such as starter packs) to help them quickly familiarize themselves with the game. Growth players have mastered the basic game content and are beginning to pursue higher achievements and richer experiences. They may churn due to rapidly increasing game difficulty, a lack of new challenges, or insufficient social interaction. Re-engagement strategies can include providing advanced guides suitable for growth players, new game levels or missions, and organizing social activities among growth players (such as team challenges) to stimulate their interest in the game and their social needs. Mature players have high loyalty to the game, but may still churn due to slow content updates, a lack of novelty, or a stagnant social circle. Recall strategies can focus on launching exclusive premium content (such as special items and hidden levels) and hosting high-end social events for mature players (such as competitive matches and offline gatherings) to meet their needs for high-quality gaming experiences and deep social interaction.

[0043] Based on the reactivation strategy direction for each player stage, specific reactivation strategies are collected and organized. These strategies can include in-game push notifications, email notifications, and event invitations, as well as out-of-game social media promotions and SMS reminders. Reactivation strategies targeting new players, growth players, and mature players are stored in corresponding stage-specific reactivation strategy libraries. Simultaneously, a strategy evaluation and update mechanism is established to regularly analyze the implementation effectiveness of reactivation strategies and adjust and optimize them based on player feedback and actual reactivation rates. For example, if a reactivation strategy targeting new players is found to be ineffective, the reasons are analyzed, and the strategy is modified or replaced with a more effective one. By continuously enriching and improving the stage-specific reactivation strategy library, the most targeted and attractive reactivation strategies can be provided to players at different stages, improving the success rate of player reactivation.

[0044] S104: Collect player operation sequences and build an operation failure mode library to identify stuck points and typical failure modes of accidental operation.

[0045] In this embodiment, multiple data collection channels are employed to comprehensively and accurately acquire player operation sequences. Within the game client, a built-in data collection module records various player operation information in real time, including but not limited to key clicks, mouse movements and clicks, skill releases, item usage, and movement direction control, as well as the timing, type, and object of these operations (e.g., which game character or item was being operated on). Simultaneously, server-side logs record operation data generated during player-server interactions, such as login and logout times, task submissions, and level entry and exit records. This data reflects the player's game progress and operational rhythm from a macro perspective. Furthermore, for games supporting peripheral operation, operation data generated by peripherals (such as game controllers or motion-sensing devices) can be collected through interfaces to obtain richer operational dimensions. The data collected from different channels are then integrated to form a complete player operation sequence dataset.

[0046] The collected player action sequence data is preprocessed to ensure data quality and usability. The player action sequences are segmented, dividing continuous action sequences into multiple subsequences based on game levels, missions, or specific scenarios to facilitate subsequent analysis at different game stages.

[0047] For each player's action sequence, and in conjunction with the game level design and mission objectives, bottlenecks are identified. By analyzing a player's actions in a particular level or mission, a bottleneck is identified when a player repeatedly performs similar actions for an extended period (a specific time threshold can be set based on the game type and level difficulty, such as 10 minutes) without achieving the level objective. For example, in a puzzle level, if a player repeatedly tries the same puzzle-solving steps but cannot solve the puzzle, and fails to advance to the next stage within the set time, then the location of that puzzle-solving step can be identified as a bottleneck. For identified bottlenecks, relevant action features are extracted, including action frequency (the number of times a specific action is performed per unit of time), action sequence (the order in which the player attempts to solve the bottleneck problem), and action target (the specific game element that is targeted at the bottleneck). For example, in a combat level, if a player repeatedly uses a certain skill to attack a specific enemy at a bottleneck, then the frequency of use of that skill, the order of use, and the type of enemy targeted are all important action features.

[0048] By analyzing abnormal actions in player action sequences, typical failure patterns caused by accidental touches are identified. Accidental touches typically manifest as players performing actions unexpectedly, such as accidentally clicking the wrong skill button while moving quickly, or accidentally pressing the exit button in a tense combat scenario. Through analysis of a large amount of player action data, common accidental touch scenarios and patterns are summarized. For example, when performing a combo attack requiring continuous clicks on specific buttons, a player might click an adjacent incorrect button due to hand tremors or excessive speed, causing the combo to be interrupted; or while browsing the game menu, a player might accidentally click the confirm button, performing an unexpected action. For the identified typical failure patterns of accidental touches, relevant features are extracted, including the time point of the accidental touch (at which stage of the game), the type of accidental touch (which button was accidentally clicked or what type of incorrect action was performed), and the sequence of actions before and after the accidental touch (other actions before and after the accidental touch to determine if the accidental touch was caused by preceding actions).

[0049] The identified bottlenecks and typical accidental touch failure patterns, along with their related characteristics, are organized and stored to construct an operation failure pattern library. Each bottleneck and typical accidental touch failure pattern is assigned a unique identifier for easy subsequent querying and retrieval. The library records detailed characteristic information for each pattern, including operation frequency, operation sequence, operation object, time of accidental touch occurrence, accidental touch type, and the sequence of operations before and after the accidental touch. Furthermore, each pattern is categorized and labeled. For example, bottlenecks are categorized by game type (e.g., puzzle, combat, adventure) and difficulty level, while typical accidental touch failure patterns are categorized by operation scenario (e.g., combat scenario, menu browsing scenario, movement scenario) and accidental touch type (e.g., button accidental touch, menu option accidental touch). In this way, a well-structured and information-rich operation failure pattern library is constructed.

[0050] S105, based on player stage, operation failure pattern library and graph features, uses a deep learning model to learn the spatiotemporal patterns and churn rules of player behavior, and predicts the probability of player churn.

[0051] In this embodiment, data related to player stages, operation failure pattern libraries, and graph features are extracted from a constructed unified data view. For player stage data, the current stage (beginner, growth, or mature) of each player is identified. Information related to typical failure patterns involving bottlenecks and accidental touches in the player's operation sequence is obtained from the operation failure pattern library, including the location and frequency of bottlenecks, and the type and timing of accidental touches. Graph feature data covers the player's social relationships and behavioral trajectories within the behavioral spatiotemporal graph. Next, this data is preprocessed.

[0052] The preprocessed player stage, operation failure mode library, and graph feature data are integrated to construct a feature vector suitable for input to a deep learning model. For player stage data, one-hot encoding is used to transform it into numerical features, for example, the novice stage is encoded as [1,0,0], the growth stage is encoded as [0,1,0], and the mature stage is encoded as [0,0,1].

[0053] For the data in the operation failure mode library, key features are extracted and quantified. For example, the total number of times a player gets stuck in a certain period of time, the frequency of different types of stuck points, the total number of accidental touches, and the proportion of different types of accidental touches are statistically analyzed, and these quantified features are used as part of the input.

[0054] For graph feature data, based on the features output by the graph propagation model, key information related to player behavior and churn is extracted, such as the player's social influence in the game, the tightness of social relationships, and the complexity of behavioral trajectories. This information is also quantified and added to the feature vector. Finally, all quantized features are combined in a specific order into a complete feature vector, which serves as the input to the deep learning model.

[0055] Based on the characteristics of the problem and the properties of the data, a suitable deep learning model architecture should be selected. Considering the need to learn the spatiotemporal patterns and churn patterns of player behavior, recurrent neural networks (RNNs) and their variants, such as long short-term memory networks (LSTMs) or gated recurrent units (GRUs), can be chosen. These models can handle sequential data, capture temporal dependencies in the data, and are suitable for analyzing changes in player behavior at different time points. Hybrid models combining convolutional neural networks (CNNs) and recurrent neural networks can also be considered. CNNs can extract local and spatial features from the data, offering advantages in analyzing spatial patterns of player behavior (such as the distribution of behavior in a game scene). Combined with RNNs, they can simultaneously handle spatiotemporal information. Furthermore, the Transformer model can be tried, as it excels in handling long-sequence data and capturing long-range dependencies in the data, enabling it to better learn complex patterns of player behavior across different times and spaces.

[0056] The constructed feature vector dataset is divided into a training set, a validation set, and a test set. The training set is used for training the model, the validation set is used to adjust the model's hyperparameters and prevent overfitting during training, and the test set is used to evaluate the model's final performance.

[0057] The selected deep learning model is trained using a training set, and its parameters are continuously adjusted through backpropagation to minimize the error between the model's output (the predicted probability of player churn) and the true label (whether a player has actually churned). During training, an appropriate loss function, such as the cross-entropy loss function, is used to measure the difference between the predicted and true values.

[0058] The model is evaluated using a validation set during training, and hyperparameters such as learning rate, batch size, and number of network layers are adjusted based on the evaluation results to optimize model performance. Early stopping is used to prevent overfitting on the training set; training is stopped when the model's performance on the validation set no longer improves.

[0059] After training, the trained deep learning models are evaluated using a test set. Multiple evaluation metrics, such as accuracy, precision, recall, F1 score, and area under the receiver operating characteristic (ROC) curve (AUC), are employed to comprehensively assess the model's performance.

[0060] Based on the evaluation results, the model with the best performance is selected as the final player churn probability prediction model. If multiple models perform differently on various metrics, the most suitable model can be selected by comprehensively considering business needs and data characteristics. For example, if the focus is on reducing the misclassification of actual churned players as non-churned players, a model with a higher recall rate can be selected; if higher overall prediction accuracy is desired, a model with a higher precision or AUC value can be selected.

[0061] New player data is input into the selected deep learning model. Based on the spatiotemporal patterns and churn characteristics of player behavior learned, the model outputs the probability value of that player churning within a certain period of time.

[0062] S106, based on the churn probability, player stage, and operation failure mode library, selects and adjusts strategies from the stage-specific recall strategy library according to individual player characteristics and churn reasons to generate personalized recall strategies.

[0063] We comprehensively collect information related to individual player characteristics and reasons for churn from the established unified data view and the data sources used in predicting player churn probability. Individual player characteristics include age, gender, gaming history (including previously played game types, game duration, etc.), spending power (such as historical recharge amount and recharge frequency), and game preferences (such as preferred game character types and gameplay).

[0064] To analyze the reasons for player churn, we combined the previously predicted churn probability with information from the failure mode database. If a player has a high churn probability and the failure mode database shows that the player frequently gets stuck on specific levels, we can initially determine that excessive game difficulty may be one of the reasons for churn. If a player has little social interaction in the game and the churn probability is increasing, then social loneliness may be the cause of churn. Simultaneously, we referenced the player's in-game behavior logs, such as chat frequency and team-up activity, to further clarify the social situation.

[0065] This study examines player action sequences recorded in an action failure pattern database to analyze the intrinsic relationship between typical failure patterns such as level-blocking and accidental touches and player churn. For example, if a player repeatedly gets stuck on a specific level, and their activity level significantly decreases after each stuck level, ultimately leading to increased churn, then that level can be identified as a key factor contributing to player churn. Simultaneously, considering the impact of accidental touches on player experience, frequent accidental touches leading to game failure may cause frustration and churn. This in-depth analysis allows for a more accurate understanding of the reasons for player churn, providing strong support for selecting appropriate recall strategies.

[0066] Based on the player stages previously defined using Hidden Markov Models (novice, growth, and mature stages), the current player is accurately categorized into the corresponding stage. Depending on the player's stage, a preliminary selection of suitable recall strategies is made from a stage-specific recall strategy library. For novice players, recall strategies might focus on providing more detailed tutorials, gifting exclusive beginner items or rewards to help them quickly familiarize themselves with the game; growth-stage players might need more challenging tasks, unlocking new game content, or providing skill improvement guidance; mature players might focus more on social interaction strategies, such as organizing exclusive social events or providing personalized social rewards. This preliminary selection narrows down the range of strategy choices and improves the targeting of strategy selection.

[0067] Based on the initial screening, the selected recall strategy is adjusted according to the individual characteristics of players and the specific reasons for churn. For example, for mature players with strong spending power who churned due to excessive game difficulty, in addition to providing standard difficulty adjustment suggestions, they can be offered exclusive high-level items or privileges to enhance their competitiveness in the game and resolve churn caused by difficulty issues. For novice players who prefer social interaction but churned due to social loneliness, in addition to providing beginner guidance, they can be assigned a dedicated social mentor to help them quickly integrate into the game's social circle and meet their social needs. Through this personalized adjustment, the recall strategy is made more aligned with the actual situation of players, improving the success rate of recall.

[0068] In some embodiments, step S102 above, which involves constructing a spatiotemporal graph of player behavior based on a unified data view, developing a graph propagation model, and outputting graph features, specifically includes: Based on a unified data view, players are treated as nodes, and the interactions between players are treated as edges. A time dimension is incorporated to form a dynamic graph structure, thus constructing a spatiotemporal graph of player behavior. Based on the spatiotemporal graph of player behavior, a graph propagation model is constructed by simulating the propagation path of churn risk in social networks through graph neural networks and message passing mechanisms. Based on the graph propagation model, the risk propagation value of each node is calculated, typical patterns of social circle loss and task chain loss are identified, and graph features are output, including node embedding vectors, risk propagation values ​​and community structure features.

[0069] In this embodiment, various types of information related to players are comprehensively extracted from the unified data view, including players' basic attributes (such as account registration information, character information, etc.), various behavioral data in the game (such as login time, game task completion status, operation records, etc.), and interaction data between players (such as friend relationships, team records, chat content, etc.).

[0070] Players are treated as nodes in the graph, with each node containing detailed information about that player. For example, a player node can record attributes such as their game level, spending amount, and frequently used game characters. Interactions between players are treated as edges connecting the nodes, with edge attributes reflecting information such as the type of interaction (e.g., teaming up, chatting, trading), the frequency of interaction, and the duration of interaction.

[0071] To incorporate the time dimension and form a dynamic graph structure, player interactions are sorted and labeled chronologically. For example, the specific time point or time period of each interaction is recorded. Thus, the graph structure dynamically changes as player interactions vary across different time slices. For instance, if a group of players frequently team up for game tasks within a specific time period, the edges between these player nodes will be denser and more active in the graph corresponding to that time period. Conversely, if player interactions decrease in other time periods, the graph structure will change accordingly. In this way, a spatiotemporal graph of player behavior that reflects changes in player behavior over time is constructed.

[0072] Based on the established spatiotemporal graph of player behavior, graph neural networks and message passing mechanisms are used to simulate the propagation path of churn risk in social networks.

[0073] Graph neural networks (GNNs) can efficiently extract and process features from nodes and edges in a graph. They take information about each node and its neighbors as input and update the node's feature representation through multi-layered neural network computation. For example, for a player node, the GNN considers its own attributes as well as the attributes and interactions of other connected player nodes to comprehensively calculate the node's new features.

[0074] The message passing mechanism is used to simulate the propagation of churn risk within the graph. Specifically, when a node shows signs of churn risk (e.g., a significant decrease in a player's activity level), it transmits this risk information to its neighboring nodes via the edges connected to it. During this transmission, the risk information is weighted according to the edge's attributes (such as interaction type and frequency). For example, if two players frequently team up for challenging tasks, their edge will have a higher weight when transmitting churn risk, meaning one player's churn risk is more likely to affect the other. By iterating through the message passing process, the propagation path of churn risk throughout the social network is simulated, thus constructing a graph propagation model.

[0075] Based on the constructed graph propagation model, a series of calculations and analyses are performed to output graph features. First, the risk propagation value of each node is calculated. Using the graph propagation model, the propagation of churn risk between different nodes is simulated. Based on the risk information received by each node and its own attributes, the node's contribution to the overall churn risk is calculated, i.e., the risk propagation value. For example, if a core player node is connected to multiple player nodes with a tendency to churn and interacts frequently, its risk propagation value will be high, meaning it has a significant impact on the churn risk of the entire social circle. Next, typical churn patterns in social circles and task chains are identified. By analyzing the risk propagation values ​​and interaction relationships of a large number of nodes in the graph, social circles or task chains with similar characteristics are identified. For example, if it is found that players in a certain social circle generally churn after completing a specific task chain, and the interaction patterns between these players have certain regularities, then this can be identified as a typical churn pattern in a social circle or a typical churn pattern in a task chain. Finally, graph features are output, including node embedding vectors, risk propagation values, and community structure features. Node embedding vectors map various node attribute information into a low-dimensional vector space using a specific algorithm, facilitating subsequent analysis and processing. Risk propagation values ​​reflect each node's ability to propagate churn risk. Community structure features describe the composition, connection methods, and relationships between different communities in the graph. For example, community detection algorithms identify communities in the graph, analyze their size, density, and interactions, and output these as community structure features. These graph features can provide crucial information for subsequent player churn prediction and intervention.

[0076] Furthermore, based on a unified data view, players are treated as nodes, interactions between players as edges, and a time dimension is incorporated to form a dynamic graph structure, constructing a spatiotemporal graph of player behavior. Specifically, this includes: Based on a unified data view, basic player attribute data is extracted, and each player is set as a node and assigned attribute features; Based on a unified data view, player interaction behavior data is extracted, and social interaction behavior is set as an edge with edge attributes. A dynamic graph structure is constructed by incorporating the time dimension, and the graph is dynamically updated through time weighting and a sliding window mechanism; By integrating nodes and their corresponding attribute features, edges and their corresponding edge attributes, and time dimension, a spatiotemporal graph of player behavior is formed.

[0077] In this embodiment, various types of data related to the player's basic attributes are filtered from the unified data view. For example, the player's account registration information, including registration time and registration channel, can reflect the player's initial way and time to enter the game; the player's character information, such as the type, level, and skill level of the selected character, with different character types and levels reflecting the player's positioning and development level in the game; and the player's consumption records, such as the amount of money recharged, the frequency of recharge, and the types of game items purchased, which can indirectly reflect the player's level of investment and preferences in the game.

[0078] The basic attribute data corresponding to each player in the data view is integrated, and each player is set as a node in the graph. Then, corresponding attribute characteristics are assigned to each node based on these attribute data. For example, player nodes with earlier registration time and higher spending are given the attribute characteristic of "experienced high-spending player"; while player nodes with lower character level and lower spending are given the attribute characteristic of "new low-spending player". In this way, each node can accurately and comprehensively reflect the basic attribute situation of the corresponding player.

[0079] Also based on a unified data view, we delve into the interactive behavior data between players. These interactive behaviors include, but are not limited to, adding and deleting friends, which reflects the establishment and changes in players' social relationships; team play, such as team frequency, team duration, and the types of tasks completed in the team, which reflects the level of cooperation and social activity among players in the game; and chat content between players, although we do not directly obtain the specific text of the chat, we can analyze the closeness of communication between players through chat frequency, chat partners, etc.

[0080] These social interactions between players are set as edges connecting nodes. Furthermore, each edge is assigned corresponding attributes based on the specific nature of the interaction. For example, edges formed between players who frequently team up to complete challenging tasks are assigned the attribute of "high-frequency, high-difficulty collaborative edge"; while edges formed between players who occasionally chat with minimal content are assigned the attribute of "low-frequency, simple communication edge". By setting edge attributes, the type and intensity of player interactions can be clearly displayed.

[0081] To ensure the constructed graph reflects changes in player behavior over time, a time dimension needs to be incorporated to create a dynamic graph structure. A time-weighted approach and a sliding window mechanism are used to achieve dynamic updates to the graph.

[0082] In terms of time weighting, different weights are assigned based on how close the interaction occurred to the current time. For example, recent interactions have a greater impact on the current player's behavior and are given higher weights, while earlier interactions have a diminishing impact over time and are given lower weights. This allows the graph to focus more on recent changes in player behavior.

[0083] The sliding window mechanism sets a specific time window, such as a week or a month. Within each time window, it collects data on player interaction behavior and changes in node attributes. When the time window slides to the next time period, the graph is updated based on the new data. For example, in the first time window, players A and B frequently team up, forming a relatively active edge; in the second time window, their teaming frequency decreases. Therefore, when updating the graph, the attributes and weights of this edge are adjusted accordingly to reflect the changes in the interaction relationships between players. In this way, the graph is dynamically updated, allowing it to reflect real-time changes in player behavior.

[0084] After completing the above steps, the nodes and their corresponding attributes, edges and their corresponding edge attributes, and the time dimension are fully integrated. Nodes with corresponding attributes are connected by edges with edge attributes, while considering the influence of the time dimension on nodes and edges, forming a complete spatiotemporal graph of player behavior that reflects the spatiotemporal characteristics of player behavior.

[0085] In this graph, each node represents a player, and its attributes describe the player's basic information. Each edge represents the interaction between players, and the edge attributes reflect the type and intensity of the interaction. The time dimension runs throughout, allowing the graph to dynamically display changes in player behavior over time. For example, by observing the attribute changes of a node in the graph at different time periods and the attribute changes of its connected edges, we can analyze the player's development trajectory in the game, changes in social relationships, and the evolution of churn risk. The resulting spatiotemporal graph of player behavior provides a rich, comprehensive, and dynamic data foundation for subsequent player churn prediction and intervention.

[0086] Furthermore, the aforementioned graph propagation model, based on the spatiotemporal graph of player behavior, simulates the propagation path of churn risk in social networks through graph neural networks and message passing mechanisms, specifically including: Based on the spatiotemporal graph of player behavior, the node feature representation is initialized, and the attribute features and initial churn risk probability of each player are used as the input feature vector; Based on the input feature vector, the loss risk information is propagated between adjacent nodes through the multi-layer message passing mechanism of the graph neural network. During the aggregation process, the propagation intensity is adjusted according to the edge attributes and time weights to form an initial graph propagation model. An attention mechanism is introduced into the message passing process of the initial graph propagation model to dynamically calculate the degree of influence of different neighbor nodes on the risk propagation of the target node, thus forming the target graph propagation model.

[0087] In this embodiment, starting from the pre-constructed spatiotemporal graph of player behavior, feature initialization operations are performed for each player node in the graph. First, the attribute features of each player are comprehensively collected. These attribute features cover multiple dimensions, such as the player's game level, which reflects the player's growth and experience accumulation in the game; the player's spending amount, which reflects the player's level of investment in the game; the player's online time, which can indirectly reflect the player's stickiness and activity level in the game; and the number of the player's friends, which shows the breadth of the player's social interaction in the game, etc.

[0088] At the same time, an initial churn risk probability is set for each player. This initial churn risk probability can be estimated based on historical data and industry experience. For example, newly registered players with short online times have a relatively high risk of churn because they haven't yet deeply experienced the game content, and therefore can be given a higher initial churn risk probability. Conversely, players who are consistently online, make frequent purchases, and have high game levels have a relatively low risk of churn, and therefore can be given a lower initial churn risk probability.

[0089] Each player's attribute characteristics and initial churn risk probability are integrated into an input feature vector.

[0090] Based on the initialized node feature representations, this study uses the multi-layer message passing mechanism of graph neural networks to simulate the propagation of churn risk in social networks. In graph neural networks, each layer acts as an "information processing station," responsible for updating and transmitting node information.

[0091] The message passing process unfolds between adjacent nodes. When a node acts as the source node, it transmits the churn risk information it carries to its neighboring nodes through the edges connected to it. During the aggregation process, the impact of edge attributes and time weights on the propagation strength is fully considered. Edge attributes include interaction type (such as teaming up, chatting, etc.) and interaction frequency. For example, if two players frequently team up for challenging tasks, the interaction frequency of their edge is high, resulting in a relatively strong propagation strength when transmitting churn risk information; conversely, if two players only chat occasionally, the interaction frequency is low, leading to a weaker propagation strength.

[0092] In terms of time weighting, adjustments are made based on the proximity of the interaction to the current time. Recent interactions have a greater impact on the spread of current churn risk and are assigned a higher time weight; while earlier interactions have a diminishing impact over time and are assigned a lower time weight. For example, a team-building activity that occurred a week ago will have a higher time weight in spreading churn risk compared to a team-building activity that occurred a month ago.

[0093] Through multiple layers of message passing and aggregation operations, the feature representations of nodes are continuously updated to reflect the spread of churn risk within the social network, ultimately forming an initial graph propagation model. This model is like a preliminary "risk propagation map," roughly showing the propagation path and intensity of churn risk among different players.

[0094] An attention mechanism is introduced into the message passing process of the initial graph propagation model to more accurately simulate the propagation of churn risk. The attention mechanism acts like a "smart filter," dynamically calculating the degree of influence of different neighboring nodes on the risk propagation to the target node.

[0095] During message passing, for each target node, the attention mechanism comprehensively considers the characteristics of all its neighboring nodes, as well as the attributes and temporal weights of the edges between them and the target node. For example, if target node A has neighboring nodes B, C, and D, the attention mechanism will analyze the attributes of nodes B, C, and D (such as game level, spending status, etc.), the interaction type and frequency of the edges between them and node A, and the temporal weights, etc.

[0096] Through calculation, the attention mechanism assigns an attention weight to each neighbor node. This weight reflects the importance of that neighbor node in the risk propagation to the target node. Neighbor nodes with higher weights have a greater impact on the target node and receive more attention when transmitting information about churn risk; neighbor nodes with lower weights have a relatively smaller impact.

[0097] Based on the calculated attention weights, the churn risk information transmitted from neighboring nodes is weighted and then aggregated onto the target node. This approach more accurately simulates the propagation of churn risk among different players, making the model more realistic. Through the optimization of the attention mechanism, the initial graph propagation model is upgraded to a target graph propagation model. This model can more accurately predict the propagation path and impact range of churn risk in social networks, providing stronger support for subsequent player churn interventions.

[0098] Furthermore, the graph-based propagation model calculates the risk propagation value for each node, identifies typical patterns of social circle attrition and task chain attrition, and outputs graph features, specifically including: Based on the graph propagation model, the risk contribution of all neighboring nodes is aggregated according to the multi-hop propagation influence of direct and indirect neighboring nodes, and the risk propagation value of each node is calculated by combining the spatiotemporal weight factor of the edge. Based on risk propagation values, typical patterns of social circle attrition are identified, and social groups of players are divided and the trend of collective activity decline is detected through community discovery algorithms. Based on the task completion sequence in the spatiotemporal graph of player behavior, we identify typical patterns of task chain loss and analyze the interruption behaviors on the task chain.

[0099] In this embodiment, based on the established graph propagation model, the risk propagation value is calculated for each node in the graph. The influence of both direct and indirect neighbors is comprehensively considered. Direct neighbors are nodes directly connected to the target node; their interaction is the closest, and their impact on the risk propagation of the target node is relatively direct. Indirect neighbors, on the other hand, are connected to the target node through other nodes; their influence goes through a certain propagation path, but it is still significant.

[0100] For each neighbor node, its risk contribution is aggregated according to the principle of multi-hop propagation. Multi-hop propagation means that risk information can be transmitted through one or more edges, and the impact of the risk gradually decreases as the number of hops increases during the transmission process. For example, a direct neighbor node has a large risk contribution to the target node, while an indirect neighbor node that is transmitted to the target node through an intermediate node will have a relatively small risk contribution.

[0101] Simultaneously, the risk contribution is further adjusted by incorporating the spatiotemporal weighting factor of the edges. This factor includes information from both time and space dimensions. In the time dimension, edges corresponding to recent interactions have higher time weights because recent interactions better reflect the current risk propagation situation. In the space dimension, edges corresponding to different types of interactions have different spatial weights; for example, edges corresponding to team-based completion of challenging tasks have higher spatial weights than edges corresponding to simple chat interactions.

[0102] The risk propagation value of each node is calculated by combining the risk contributions of all neighboring nodes and the spatiotemporal weight factors of the edges, using methods such as weighted summation. For example, for node A, its direct neighbor node B has a risk contribution of 0.3 and an edge spatiotemporal weight factor of 0.8; its indirect neighbor node C has a risk contribution of 0.2, and its edge spatiotemporal weight factor is adjusted to 0.5 after being propagated through intermediate nodes. Therefore, node A's risk propagation value is calculated by comprehensively considering the situation of all neighboring nodes in this way, and this value accurately reflects the degree to which the node is affected by the risk of churn in the social network.

[0103] Based on the calculated risk propagation value of each node, typical patterns of social circle churn are identified. Community detection algorithms are used to divide players into social groups. These algorithms act like "intelligent classifiers," grouping players into different social groups based on factors such as interaction relationships and similarities. For example, players who frequently team up and chat will be grouped into the same social group, while players with less interaction may be grouped into different groups.

[0104] After dividing the social groups, the decline trend of collective activity in each social group is detected. Collective activity can be measured by indicators such as the online time of players within the group, the frequency of interaction, and the completion of tasks. For example, if a social group experiences a significant decrease in the average online time of players, a sharp drop in the frequency of interaction, and a significant decrease in the number of tasks completed over a period of time, then it can be considered that the social group is experiencing a decline in collective activity.

[0105] When a decline in the overall activity level of a social community is detected, analysis is performed in conjunction with the risk propagation values ​​of the nodes within that community. If the risk propagation values ​​of most nodes within the community are high, it indicates a high risk of churn within the social community, potentially representing a typical pattern of social circle churn. For example, if a previously active team-based social community experiences a recent decrease in player interaction and an increase in the risk propagation values ​​of most members, then this can be considered a typical case of social circle churn. This pattern could be caused by factors such as untimely game content updates or inadequate social mechanisms.

[0106] Based on the task completion sequences in the player behavior spatiotemporal graph, typical patterns of task chain drop-off are identified. The task completion sequences of each player in the game are analyzed, recording information such as the order and time intervals in which tasks are completed. For example, player A's task completion sequence might be completing beginner task 1 first, then main task 2, followed by side task 3, and so on.

[0107] After outlining the task completion sequence, analyze the interruption behaviors within the task chain. Interruption behaviors refer to situations where players pause or abandon tasks during a series of tasks. For example, after completing main quest 5, a player might not continue with the subsequent main quest 6 for an extended period, or might simply abandon the task chain altogether.

[0108] By analyzing a large number of player task completion sequences, common task chain interruption patterns were identified. For example, it was found that many players are prone to task chain interruptions after completing tasks of a certain difficulty level; or that the interruption rate is higher for certain types of tasks (such as collection tasks requiring a large time investment). These common task chain interruption patterns are typical task chain churn patterns. Further analysis of the reasons behind these patterns may reveal factors such as excessively high task difficulty, unreasonable rewards, or cumbersome task processes, providing a basis for game developers to optimize task design.

[0109] In some embodiments, step S103 above, which involves dividing the player stages into novice, growth, and maturity stages based on graph features and a hidden Markov model, specifically includes: Based on graph features, player behavior observation sequences are extracted as input to a hidden Markov model. These player behavior observation sequences include login frequency, task completion rate, social interaction intensity, payment behavior, and game duration. Construct a Hidden Markov Model and set multiple hidden states for the Hidden Markov Model corresponding to different player stages, including the novice stage, the growth stage, and the mature stage; Based on the player behavior observation sequence, the state transition probability and observation probability distribution of the hidden state are calculated using the forward-backward algorithm, and the hidden Markov model is trained accordingly. Based on the trained Hidden Markov Model, the Viterbi algorithm is used to decode the optimal state sequence of the player and determine the current stage of the player.

[0110] In this embodiment, after acquiring relevant data based on graph features, the behavioral observation sequence of each player is extracted, and this sequence will serve as input data for the Hidden Markov Model. Specifically, regarding login frequency, the number of times a player logs in within a specific time period is recorded in detail. For example, the number of times a player logs in to the game each day within a week is counted. If a player logs in 7 times a week, it is considered high-frequency login; if they log in 1-2 times a week, it is considered low-frequency login. Task completion rate refers to the proportion of game-set tasks completed by the player. For example, if there are 10 main quests in the game and the player completes 8, their task completion rate is 80%. Social interaction intensity is measured through the player's interaction behavior with friends, such as the number of times they team up and the number of chat messages. If a player teams up 10 times and sends 50 chat messages within a week, it indicates that their social interaction intensity is high. Payment behavior records the player's spending in the game, including the amount spent, the number of times spent, and the type of items spent, such as purchasing equipment, props, or skins. Game time is calculated by counting the length of time a player spends logging into the game each time and the total online time. For example, if a player logs into the game for 2 hours at a time, their total online time for a week is 10 hours. Arrange these data in chronological order to form a unique behavioral observation sequence for each player, providing basic information for subsequent model processing.

[0111] A Hidden Markov Model (HMM) is constructed to uncover the underlying stages behind player behavior. Multiple hidden states are set for this model, corresponding to different player stages: the novice stage, the growth stage, and the mature stage. Novice players are typically unfamiliar with the game rules and controls, their login frequency may be unstable, their task completion rate low, their social interaction limited, their spending behavior relatively conservative, and their playtime may be short. Growth stage players gradually become familiar with the game, their login frequency stabilizes and increases, their task completion rate improves, they begin to actively participate in social interaction, their spending behavior gradually increases, and their playtime correspondingly extends. Mature stage players have a deep understanding of the game, their login frequency remains high and regular, their task completion rate is very high, they engage in frequent social interaction and form stable social circles, their spending behavior is more rational and may have certain patterns, and their playtime is relatively stable. By setting these three hidden states, the model can better simulate the development and changes of players during the game process.

[0112] The extracted player behavior observation sequences are input into a pre-constructed Hidden Markov Model (HMM), and the model is trained using a forward-backward algorithm. The forward algorithm starts from the beginning of the sequence and progressively calculates the probability of being in each hidden state at each time point, as if moving forward along a timeline, recording the likelihood of the player being in each stage at different times. The backward algorithm starts from the end of the sequence and calculates the probability of being in each hidden state at each time point in reverse, as if traversing back from the end, understanding the conditional probability of the player being in each stage at different times. By combining these two algorithms, the state transition probabilities and observation probability distributions of the hidden states can be accurately calculated. The state transition probability describes the probability of a player moving from one stage to another, such as the probability of moving from the beginner stage to the growth stage. The observation probability distribution reflects the probability of a specific observation occurring in a given hidden state, such as the probability of a player logging in more frequently during the growth stage. After training with a large number of player behavior observation sequences, the model continuously adjusts its parameters, making the calculated probability distribution more consistent with reality, thereby improving the model's accuracy and reliability.

[0113] Based on a trained Hidden Markov Model (HMM), the Viterbi algorithm is used to decode the player's optimal state sequence. The Viterbi algorithm finds the state sequence most likely to produce the observed sequence among all possible state sequences. Specifically, starting from the beginning of the sequence, the algorithm calculates the optimal path probability for each hidden state at each time point and records the corresponding path. As the sequence progresses, the optimal path probability and path are continuously updated until the end of the sequence. The final optimal path is the player's optimal state sequence, which can be used to determine the player's current stage. For example, if the optimal state sequence shows the highest probability of the player being in the beginner stage, then the player is currently in the beginner stage; if the probability is highest in the growth stage, then the player is in the growth stage; if the probability is highest in the mature stage, then the player is in the mature stage. In this way, the player's stage can be accurately classified, providing a strong basis for game operators to formulate targeted strategies.

[0114] In some embodiments, step S104 above, which involves collecting player operation sequences and constructing an operation failure mode library for identifying stuck points and typical failure modes of accidental touches, specifically includes: Record the player's action type, action time, and action result to form a player action sequence; Player operation sequences are preprocessed and feature extracted. The operation flow is segmented using a sliding window mechanism to extract operation frequency, operation interval duration, and operation success rate, and to establish a structured operation feature library. Based on the operation feature library, density clustering algorithm is used to identify high-frequency failed operation clusters, and pattern matching technology is combined to determine the bottleneck pattern. The bottleneck pattern is used to represent the performance of multiple consecutive failed operations in a specific game segment. Based on the operation feature library, the accidental touch operation pattern is identified by the anomaly detection algorithm. The accidental touch operation pattern is used to represent the performance of unexpected high-frequency short-interval operation combinations. An operation failure mode library is constructed based on checkpoint mode and accidental touch operation mode. The operation failure mode library includes mode type, triggering condition, impact degree and associated churn rate indicators.

[0115] In this embodiment, during game operation, the game's built-in data acquisition system comprehensively and accurately records each player's operation type, operation time, and operation result, thus forming a complete player operation sequence. Operation types cover various behaviors in the game; for example, in role-playing games, this includes moving, attacking, releasing skills, and using items; in strategy games, it includes building structures, training soldiers, and issuing combat commands. Operation time is accurate to the millisecond level to accurately record the moment each operation occurs, facilitating subsequent analysis of the time intervals and sequence of operations. Operation results clearly indicate whether the operation was successful, such as whether an attack hit the target, whether a skill was successfully released, or whether an item was used correctly.

[0116] The recorded player action sequences are preprocessed to remove invalid and abnormal data. After preprocessing, a sliding window mechanism is used to segment the action flow. Within each window, features such as action frequency, action interval duration, and action success rate are extracted. Action frequency is the ratio of the number of times a certain action type occurs within the window to the total number of actions in the window; action interval duration is the time difference between two adjacent actions; and action success rate is the ratio of the number of successful actions within the window to the total number of actions. These features are then organized according to a certain structure, such as using player ID, game level, and action type as indexes, to build a structured action feature library.

[0117] Based on the established operation feature database, density clustering algorithm is used to identify high-frequency failed operation clusters. Density clustering divides data points into different clusters according to their density distribution. In the operation feature database, relevant features of failed operations are used as data points. Density clustering algorithm identifies clusters of data points with high failure frequency and similar operation features; these clusters represent high-frequency failed operations. Pattern matching technology is then used to further analyze these high-frequency failed operation clusters to determine bottleneck patterns. Pattern matching technology matches high-frequency failed operation clusters with specific stages in the game. For example, in a game level, if a player repeatedly fails to attack a specific enemy, and these failed operations are similar in characteristics such as operation frequency and interval duration, pattern matching technology can determine that the operation pattern of attacking the specific enemy in that level is a bottleneck pattern, representing the performance of repeatedly failing to attack in a specific game stage.

[0118] Also based on an operation feature database, an anomaly detection algorithm is used to identify accidental touch operation patterns. The anomaly detection algorithm can identify operations that do not conform to normal patterns from a large amount of normal operation data. In the operation feature database, accidental touch operations typically manifest as unexpected, high-frequency, short-interval combinations of operations. For example, a player might rapidly click a button multiple times in a short period of time, and these operations are not intentional but likely due to accidental touches. The anomaly detection algorithm identifies these unexpected, high-frequency, short-interval combinations of operations by analyzing features such as operation frequency and operation interval duration, defining them as accidental touch operation patterns. This pattern is used to represent the behavior of unexpected, high-frequency, short-interval combinations of operations.

[0119] Based on the identified stuck-point patterns and accidental touch patterns, an operation failure mode library is constructed. The library records the type of each mode in detail, clearly identifying whether it is a stuck-point pattern or an accidental touch pattern. It also records the triggering conditions of each mode; for example, a stuck-point pattern might be triggered when encountering a specific game level, facing a specific enemy, or completing a specific task; an accidental touch pattern might be triggered due to improper player hand posture, an unreasonable interface layout, or other similar situations.

[0120] Assess the impact of each mode. For example, the level-blocking mode may cause players to spend too much time on that level, resulting in a poor gaming experience or even causing players to give up on the game; the accidental operation mode may cause players to accidentally consume items or trigger unnecessary battles, thus affecting the game progress.

[0121] This study calculates the correlation churn rate between each game mode and player churn, representing the percentage of players who leave after that mode is introduced. By analyzing data from a large number of players, accurate correlation churn rates are obtained, providing game developers with strong support for optimizing game design and improving the user experience. For example, if a certain level-blocking mode has a high correlation churn rate, game developers can adjust the difficulty of that level or optimize the operation prompts; if a certain accidental touch operation mode has a high correlation churn rate, the interface layout can be optimized or accidental touch prevention mechanisms can be added.

[0122] In some embodiments, step S105 above, which involves using a deep learning model to learn the spatiotemporal patterns and churn rules of player behavior based on player stage, operation failure pattern library, and graph features, and predicting the player churn probability, specifically includes: Player stages are encoded as one-hot vectors, and operation failure mode matching is quantified as feature values. These features are then concatenated with node embedding vectors and risk propagation values ​​in the graph features to form a comprehensive feature vector. A graph neural network branch is set to handle social relationship features, a recurrent neural network branch is set to handle behavioral sequence features, and a fully connected network branch is set to handle static attributes and failure mode features. The outputs of each network are weighted and fused together using an attention mechanism to form a deep learning model with a multi-branch neural network structure. Based on the comprehensive feature vector, a deep learning model is trained to learn the spatiotemporal patterns and churn patterns of player behavior; The trained deep learning model is used to predict the probability of player churn and is then categorized and labeled according to risk level.

[0123] In this embodiment, the player stages are encoded using one-hot encoding, transforming them into one-hot vectors. For example, if the player stages are divided into three categories: beginner, growth, and maturity, then the one-hot vector corresponding to the beginner stage could be [1,0,0], the growth stage [0,1,0], and the maturity stage [0,0,1]. This encoding method clearly distinguishes the different stages, facilitating model processing.

[0124] For each operation failure pattern in the database, a matching and metric method is used. By statistically analyzing the frequency and severity of various operation failure patterns encountered by players in the game, these metrics are converted into specific feature values. For example, if a player frequently encounters a level-blocking pattern, and each block lasts for a long time, the feature value corresponding to that level-blocking pattern will be higher; if accidental touch patterns occur less frequently and have a smaller impact, their feature value will be relatively lower.

[0125] Node embedding vectors and risk propagation values ​​are obtained from the graph features. Node embedding vectors are abstract representations of the features of each node (such as players, game items, levels, etc.) in the game graph, reflecting the node's position and attribute information in the graph; risk propagation values ​​represent the degree to which risk (such as player churn risk) propagates from one node to other nodes in the graph.

[0126] The unique-hot vectors of player stages, the quantized feature values ​​of operation failure modes, the node embedding vectors in the graph features, and the risk propagation values ​​are concatenated to form a comprehensive feature vector. This comprehensive feature vector contains information on player stages, operational behaviors, social relationships, and other aspects, providing a rich data foundation for subsequent model training.

[0127] We can use graph neural network (Graph Neural Network) branches to handle social relationship features. Graph Neural Networks are excellent at capturing the complex relationships between nodes in the game graph, such as friend relationships and team relationships between players. Through Graph Neural Network branches, we can delve deeper into these social relationships and learn their impact on player behavior and churn probability. For example, if a player has many active friends and frequently plays in teams with them, that player's churn probability may be relatively low. Graph Neural Network branches can learn the potential link between these social relationships and churn probability.

[0128] Recurrent neural network (RNN) branches are used to process behavioral sequence features. A player's behavioral sequence is a series of actions arranged chronologically and exhibiting time dependence. RNNs (such as LSTM or GRU) can process this type of temporally related data, learning patterns and regularities in player behavior over time. For example, if a player frequently makes in-app purchases within a certain timeframe and then suddenly stops, this behavioral change may indicate impending player churn, and RNN branches can capture this temporal behavioral shift.

[0129] The fully connected network branch handles static attributes and failure mode features. Static attributes include relatively fixed information such as the player's age, gender, and game level, while failure mode features are the quantified feature values ​​of the aforementioned operation failure patterns. The fully connected network can perform non-linear transformations and combinations of these features to explore their relationship with player churn probability. For example, younger players may experience a faster loss of novelty in a game, and if they simultaneously experience more operation failure patterns, their churn probability may be higher. The fully connected network branch can learn the correlation between this feature combination and churn probability.

[0130] To better integrate the outputs of various branch networks, an attention mechanism is introduced. This mechanism automatically assigns different weights to each branch network's output based on its importance to the final prediction result. For example, in some cases, social relationship features have a significant impact on player churn probability, so the attention mechanism will assign higher weights to the outputs of the graph neural network branch; while in other cases, behavioral sequence features may be more critical, and the attention mechanism will increase the weights of the recurrent neural network branch's output. By weighting and fusing the outputs of each network through the attention mechanism, a deep learning model with a multi-branch neural network structure is formed. This model can comprehensively utilize information from multiple sources, improving prediction accuracy.

[0131] The constructed comprehensive feature vector is used as input data and fed into a pre-built deep learning model for training. During training, a supervised learning approach is employed, using a large amount of player data with known churn rates as training samples. Each training sample contains a comprehensive feature vector and a corresponding churn label (churned or not churned). The model continuously adjusts its parameters to minimize the error between the predicted result and the true label. Specifically, based on the input comprehensive feature vector, the model uses various branch networks to extract and transform features, then fuses the outputs through an attention mechanism to obtain a predicted value for the player churn probability. The predicted value is compared with the true label, the error (such as cross-entropy loss) is calculated, and the model parameters are adjusted using the error backpropagation algorithm to make the model more accurate in subsequent predictions. This training is repeated multiple times until the model's performance reaches satisfactory levels, meaning the model can effectively learn the spatiotemporal patterns and churn patterns of player behavior.

[0132] Based on the trained deep learning model, new player data (also constructed as a comprehensive feature vector) is input into the model. The model will output a predicted churn probability value for that player based on the learned patterns and rules. The churn probability is a value between 0 and 1. The closer the value is to 1, the greater the likelihood of the player churning; the closer the value is to 0, the less likely the player is to churn.

[0133] To more clearly illustrate player churn risk, players are categorized and labeled according to risk level. For example, players with a churn probability between 0 and 0.3 can be labeled as low-risk players; these players are less likely to churn, and game operators can provide them with regular operational activities such as pushing new game content and holding regular events. Players with a churn probability between 0.3 and 0.7 are labeled as medium-risk players; these players have some churn risk, and game operators can implement personalized operational strategies for them, such as providing exclusive benefits and game guidance. Players with a churn probability between 0.7 and 1 are labeled as high-risk players; these players are more likely to churn, and game operators need to pay close attention and take urgent measures, such as one-on-one communication and offering high rewards, to retain these players. In this way, game operators can develop targeted operational strategies based on players' churn risk levels to improve player retention rates.

[0134] In some embodiments, in step S106 above, the step of selecting and adjusting strategies from a stage-specific recall strategy library based on churn probability, player stage, and operation failure mode library, according to individual player characteristics and churn reasons, to generate a personalized recall strategy, specifically includes: Based on historical data on player stages and strategy effectiveness, a basic strategy framework is selected and scored from a stage-specific recall strategy library. Based on the operation failure mode library, the basic strategy framework is adjusted in multiple dimensions, including content, timing and intensity, to form a preliminary personalized recall strategy. The strategy strength coefficient is calculated based on the churn probability, and specific strategy parameters are determined through dynamic weight allocation. The intensity of the initial personalized recall strategy is adjusted based on the specific strategy parameters to generate a target personalized recall strategy.

[0135] In this embodiment, based on the player's current stage, a strategy framework suitable for that stage is selected from a stage-specific recall strategy library. This stage-specific recall strategy library is pre-built according to the characteristics and needs of different player stages, and includes various recall strategy examples for specific stages, such as a beginner-friendly guidance strategy for novice players and a new content push strategy for experienced players.

[0136] After selecting basic strategy frameworks suitable for the current player stage, they are scored using historical effectiveness data. This historical data records player feedback on past use of various recall strategies, including recall success rates and subsequent player activity improvements. By analyzing this data, each basic strategy framework is assigned a score, reflecting its effectiveness in similar past situations. For example, if a social interaction incentive strategy targeting growing players has successfully recalled a large number of churned players in their growth stage, and these players showed significant activity improvements after recall, then this strategy framework will receive a high score. In this way, strategies with higher scores and a higher probability of effectiveness are selected from multiple basic strategy frameworks as the basis for subsequent adjustments.

[0137] The system acquires information on player error patterns, stored in an error pattern database. This database covers various error patterns encountered by players during gameplay, such as level-blocking and accidental touches. Based on the specific error patterns, the selected basic strategy framework is adjusted in terms of content, timing, and intensity.

[0138] In terms of content, add targeted content based on the failure patterns. For example, if players frequently encounter stuck levels, the recall strategy can include detailed guides, hints, or additional item support for those stuck levels to help players overcome the difficulties.

[0139] In terms of timing, the triggering time of the recall strategy is determined by the timing of when the operation failure mode occurs. For example, if players frequently fail and leave after completing a certain level, the recall strategy can be triggered when the player approaches that level again to provide timely assistance.

[0140] In terms of intensity, the strength of the recall strategy is adjusted based on the severity of the operation failure pattern. If a player's accidental touch pattern is severe, leading to multiple unintended actions that affect the game experience, the intensity of the recall strategy can be appropriately increased, such as by providing more generous compensation rewards or more detailed operation instructions. Through adjustments in these three dimensions, the basic strategy framework is made more aligned with the individual circumstances of players, forming a preliminary personalized recall strategy.

[0141] Based on the previously predicted player churn probability, calculate the strategy strength coefficient. A higher churn probability indicates a greater risk of player loss, and the strategy strength coefficient should be increased accordingly to enhance the effectiveness of the recall strategy. For example, if the player churn probability is 0.8, they are considered high-risk churners, so the strategy strength coefficient can be set to a higher value, such as 1.5; if the churn probability is 0.3, they are considered low-risk churners, and the strategy strength coefficient can be set to 0.8.

[0142] After determining the strategy strength coefficient, specific strategy parameters are determined through dynamic weight allocation. This dynamic weight allocation considers multiple factors, including the player's stage, the importance of the failure mode, and the strategy strength coefficient. For example, for novice players, strategy parameters related to the tutorial might be given higher weights; if the failure mode significantly impacts the player's gaming experience, the weights of related strategy parameters will also increase accordingly. Simultaneously, the strategy strength coefficient affects the final values ​​of each parameter; the higher the coefficient, the greater the adjustment range of the relevant strategy parameter values. In this way, by comprehensively considering multiple factors, specific strategy parameters suitable for the player are determined.

[0143] Based on the determined specific strategy parameters, the intensity of the initial personalized recall strategy is adjusted. For example, if the reward strength parameter is high, the number of rewards given to players or the value of the rewards can be increased in the recall strategy; if the communication frequency parameter is high, the number of communications with players can be increased, such as sending game reminders and event notifications more frequently.

[0144] By adjusting the intensity of the initial personalized recall strategy, the content, timing, and intensity are more precisely matched to the individual characteristics and reasons for player churn, ultimately generating a targeted personalized recall strategy. This strategy can more effectively attract churned players back to the game, improving the success rate of recall and the subsequent activity of players. For example, for a player in the mature stage who churned due to frequent level-blocking challenges, the generated targeted personalized recall strategy might include sending detailed level guides and extra powerful items when the player approaches a level-blocking challenge, while communicating with the player frequently to provide encouragement and guidance on game progress, thereby increasing the likelihood of the player returning to the game.

[0145] Reference Figure 2 An embodiment of the present invention provides an AI-based player churn early warning and intervention system 2, wherein system 2 specifically includes: Data processing module 201 is used to collect player profile data, clean, transform and merge the player profile data to form a unified data view; The graph feature module 202 is used to construct a spatiotemporal graph of player behavior based on a unified data view, develop a graph propagation model, and output graph features. The player stage module 203 is used to divide the player stage into novice, growth and maturity stages based on graph features and hidden Markov models, and to build a stage-specific recall strategy library through the player stage. Player operation module 204 is used to collect player operation sequences and build an operation failure mode library to identify stuck points and typical failure modes of accidental operation. The churn prediction module 205 is used to predict the churn probability of players by learning the spatiotemporal patterns and churn rules of player behavior using a deep learning model based on player stage, operation failure mode library and graph features. The recall strategy module 206 is used to select and adjust strategies from the stage-specific recall strategy library based on churn probability, player stage, and operation failure mode library, according to individual player characteristics and churn reasons, to generate personalized recall strategies.

[0146] It is understandable that, such as Figure 1 The content of the AI-based player churn warning and intervention method embodiments shown are all applicable to the AI-based player churn warning and intervention system embodiments. The specific functions implemented by the AI-based player churn warning and intervention system embodiments are as follows: Figure 1 The illustrated AI-based player churn warning and intervention method is the same as the one shown, and achieves the same beneficial effects. Figure 1 The beneficial effects achieved by the AI-based player churn warning and intervention method shown in the example are the same.

[0147] It should be noted that the information interaction and execution process between the above systems are based on the same concept as the method embodiments of the present invention. For details on their specific functions and technical effects, please refer to the method embodiments section, which will not be repeated here.

[0148] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is merely an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the system can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiments can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit. Furthermore, the specific names of the functional units and modules are only for easy differentiation and are not intended to limit the scope of protection of this application. The specific working process of the units and modules in the above system can be referred to the corresponding process in the foregoing method embodiments, and will not be repeated here.

[0149] Reference Figure 3 The present invention also provides a computer device 3, including: a memory 302 and a processor 301, and a computer program 303 stored on the memory 302. When the computer program 303 is executed on the processor 301, it implements the AI-based player churn warning and intervention method as described in any of the above methods.

[0150] The computer device 3 may be a desktop computer, laptop, handheld computer, or cloud server, etc. The computer device 3 may include, but is not limited to, a processor 301 and a memory 302. Those skilled in the art will understand that... Figure 3 The computer device 3 is merely an example and does not constitute a limitation on the computer device 3. It may include more or fewer components than shown in the figure, or combine certain components, or different components, such as input / output devices, network access devices, etc.

[0151] The processor 301 may be a Central Processing Unit (CPU), or it may be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. A general-purpose processor may be a microprocessor or any conventional processor.

[0152] In some embodiments, the memory 302 may be an internal storage unit of the computer device 3, such as a hard disk or memory of the computer device 3. In other embodiments, the memory 302 may be an external storage device of the computer device 3, such as a plug-in hard disk, smart media card (SMC), secure digital (SD) card, flash card, etc., equipped on the computer device 3. Furthermore, the memory 302 may include both internal and external storage units of the computer device 3. The memory 302 is used to store the operating system, applications, boot loader, data, and other programs, such as the program code of the computer program. The memory 302 can also be used to temporarily store data that has been output or will be output.

[0153] This invention also provides a computer-readable storage medium storing a computer program thereon, which, when executed by a processor, implements the AI-based player churn warning and intervention method as described in any of the above methods.

[0154] In this embodiment, if the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program includes computer program code, which can be in the form of source code, object code, executable files, or certain intermediate forms. The computer-readable medium can include at least: any entity or device capable of carrying computer program code to a photographing device / terminal device, a recording medium, a computer memory, a read-only memory (ROM), a random access memory (RAM), an electrical carrier signal, a telecommunication signal, and a software distribution medium. Examples include USB flash drives, portable hard drives, magnetic disks, or optical disks. In some jurisdictions, according to legislation and patent practice, computer-readable media cannot be electrical carrier signals or telecommunication signals.

[0155] In the above embodiments, the descriptions of each embodiment have different focuses. For parts that are not described in detail or recorded in a certain embodiment, please refer to the relevant descriptions of other embodiments.

[0156] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0157] In the embodiments disclosed in this application, it should be understood that the disclosed devices / terminal equipment and methods can be implemented in other ways. For example, the device / terminal equipment embodiments described above are merely illustrative. For instance, the division of modules or units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the displayed or discussed mutual coupling or direct coupling or communication connection may be through some interfaces; the indirect coupling or communication connection between devices or units may be electrical, mechanical, or other forms.

[0158] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

Claims

1. An AI-based method for player churn early warning and intervention, characterized in that, The method specifically includes: Collect player profile data, clean, transform, and merge the player profile data to form a unified data view; Based on a unified data view, a spatiotemporal graph of player behavior is constructed, a graph propagation model is developed, and graph features are output. Based on graph features, the player stages are divided into novice, growth and maturity stages according to the Hidden Markov Model, and a stage-specific recall strategy library is constructed based on the player stages. Collect player action sequences and build an action failure mode library to identify stuck points and typical failure modes of accidental actions; Based on player stage, operation failure pattern library and graph features, deep learning models are used to learn the spatiotemporal patterns and churn rules of player behavior, and predict the probability of player churn. Based on a library of churn probability, player stage, and operation failure patterns, strategies are selected and adjusted from a stage-specific recall strategy library according to individual player characteristics and reasons for churn, generating personalized recall strategies.

2. The method according to claim 1, characterized in that, The process of constructing a spatiotemporal graph of player behavior based on a unified data view, developing a graph propagation model, and outputting graph features specifically includes: Based on a unified data view, players are treated as nodes, and the interactions between players are treated as edges. A time dimension is incorporated to form a dynamic graph structure, thus constructing a spatiotemporal graph of player behavior. Based on the spatiotemporal graph of player behavior, a graph propagation model is constructed by simulating the propagation path of churn risk in social networks through graph neural networks and message passing mechanisms. Based on the graph propagation model, the risk propagation value of each node is calculated, typical patterns of social circle loss and task chain loss are identified, and graph features are output, including node embedding vectors, risk propagation values ​​and community structure features.

3. The method according to claim 2, characterized in that, The method, based on a unified data view, uses players as nodes, player interactions as edges, and incorporates a time dimension to form a dynamic graph structure, constructing a spatiotemporal graph of player behavior. Specifically, this includes: Based on a unified data view, basic player attribute data is extracted, and each player is set as a node and assigned attribute features; Based on a unified data view, player interaction behavior data is extracted, and social interaction behavior is set as an edge with edge attributes. A dynamic graph structure is constructed by incorporating the time dimension, and the graph is dynamically updated through time weighting and a sliding window mechanism; By integrating nodes and their corresponding attribute features, edges and their corresponding edge attributes, and time dimension, a spatiotemporal graph of player behavior is formed.

4. The method according to claim 2, characterized in that, The aforementioned graph propagation model, based on the spatiotemporal graph of player behavior, simulates the propagation path of churn risk in social networks through graph neural networks and message passing mechanisms, and specifically includes: Based on the spatiotemporal graph of player behavior, the node feature representation is initialized, and the attribute features and initial churn risk probability of each player are used as the input feature vector; Based on the input feature vector, the loss risk information is propagated between adjacent nodes through the multi-layer message passing mechanism of the graph neural network. During the aggregation process, the propagation intensity is adjusted according to the edge attributes and time weights to form an initial graph propagation model. An attention mechanism is introduced into the message passing process of the initial graph propagation model to dynamically calculate the degree of influence of different neighbor nodes on the risk propagation of the target node, thus forming the target graph propagation model.

5. The method according to claim 2, characterized in that, The graph-based propagation model calculates the risk propagation value for each node, identifies typical patterns of social circle attrition and task chain attrition, and outputs graph features, specifically including: Based on the graph propagation model, the risk contribution of all neighboring nodes is aggregated according to the multi-hop propagation influence of direct and indirect neighboring nodes, and the risk propagation value of each node is calculated by combining the spatiotemporal weight factor of the edge. Based on risk propagation values, typical patterns of social circle attrition are identified, and social groups of players are divided and the trend of collective activity decline is detected through community discovery algorithms. Based on the task completion sequence in the spatiotemporal graph of player behavior, we identify typical patterns of task chain loss and analyze the interruption behaviors on the task chain.

6. The method according to claim 1, characterized in that, The method of dividing player stages into novice, growth, and maturity stages based on graph features and using a Hidden Markov Model specifically includes: Based on graph features, player behavior observation sequences are extracted as input to a hidden Markov model. These player behavior observation sequences include login frequency, task completion rate, social interaction intensity, payment behavior, and game duration. Construct a Hidden Markov Model and set multiple hidden states for the Hidden Markov Model corresponding to different player stages, including the novice stage, the growth stage, and the mature stage; Based on the player behavior observation sequence, the state transition probability and observation probability distribution of the hidden state are calculated using the forward-backward algorithm, and the hidden Markov model is trained accordingly. Based on the trained Hidden Markov Model, the Viterbi algorithm is used to decode the optimal state sequence of the player and determine the current stage of the player.

7. The method according to claim 1, characterized in that, The process of collecting player action sequences and constructing an action failure mode library to identify stuck points and typical failure patterns of accidental actions specifically includes: Record the player's action type, action time, and action result to form a player action sequence; Player operation sequences are preprocessed and feature extracted. The operation flow is segmented using a sliding window mechanism to extract operation frequency, operation interval duration, and operation success rate, and to establish a structured operation feature library. Based on the operation feature library, density clustering algorithm is used to identify high-frequency failed operation clusters, and pattern matching technology is combined to determine the bottleneck pattern. The bottleneck pattern is used to represent the performance of multiple consecutive failed operations in a specific game segment. Based on the operation feature library, the accidental touch operation pattern is identified by the anomaly detection algorithm. The accidental touch operation pattern is used to represent the performance of unexpected high-frequency short-interval operation combinations. An operation failure mode library is constructed based on checkpoint mode and accidental touch operation mode. The operation failure mode library includes mode type, triggering condition, impact degree and associated churn rate indicators.

8. The method according to claim 2, characterized in that, The method, based on player stage, operation failure pattern library, and graph features, utilizes a deep learning model to learn the spatiotemporal patterns and churn patterns of player behavior, and predicts the probability of player churn. Specifically, this includes: Player stages are encoded as one-hot vectors, and operation failure mode matching is quantified as feature values. These features are then concatenated with node embedding vectors and risk propagation values ​​in the graph features to form a comprehensive feature vector. A graph neural network branch is set to handle social relationship features, a recurrent neural network branch is set to handle behavioral sequence features, and a fully connected network branch is set to handle static attributes and failure mode features. The outputs of each network are weighted and fused together using an attention mechanism to form a deep learning model with a multi-branch neural network structure. Based on the comprehensive feature vector, a deep learning model is trained to learn the spatiotemporal patterns and churn patterns of player behavior; The trained deep learning model is used to predict the probability of player churn and is then categorized and labeled according to risk level.

9. The method according to any one of claims 1 to 8, characterized in that, The system, based on a library of churn probability, player stage, and operation failure patterns, selects and adjusts strategies from a stage-specific recall strategy library according to individual player characteristics and churn reasons to generate personalized recall strategies. Specifically, this includes: Based on historical data on player stages and strategy effectiveness, a basic strategy framework is selected and scored from a stage-specific recall strategy library. Based on the operation failure mode library, the basic strategy framework is adjusted in multiple dimensions, including content, timing and intensity, to form a preliminary personalized recall strategy. The strategy strength coefficient is calculated based on the churn probability, and specific strategy parameters are determined through dynamic weight allocation. The intensity of the initial personalized recall strategy is adjusted based on the specific strategy parameters to generate a target personalized recall strategy.

10. An AI-based player churn early warning and intervention system, characterized in that, The system specifically includes: The data processing module is used to collect player profile data, clean, transform, and merge the player profile data to form a unified data view; The graph feature module is used to construct a spatiotemporal graph of player behavior based on a unified data view, develop a graph propagation model, and output graph features. The player stage module is used to divide the player stage into novice, growth and maturity stages based on graph features and hidden Markov models, and to build a stage-specific recall strategy library based on the player stage. The player operation module is used to collect player operation sequences and build an operation failure mode library to identify stuck points and typical failure modes of accidental operation. The churn prediction module is used to predict the probability of player churn by learning the spatiotemporal patterns and churn rules of player behavior using a deep learning model based on player stage, operation failure pattern library and graph features. The recall strategy module is used to select and adjust strategies from a stage-specific recall strategy library based on churn probability, player stage, and operation failure mode library, according to individual player characteristics and reasons for churn, to generate personalized recall strategies.

Images