Android emulator game intelligent recommendation method and device and readable storage medium

Abstract

The application discloses an Android simulator game intelligent recommendation method and device and a readable storage medium, and comprises the following steps: firstly, multi-dimensional feature data of users and games on both sides is comprehensively collected to form a structured data set; through feature processing on the data, a standardized feature vector of the users and the games is constructed; based on the vectors, a multi-path recall, rough sorting, fine sorting and rearrangement cascading filtering process is adopted to generate a sorted recommendation list; the method can render and display the recommendation result according to the real-time simulator operation scene of the user, and collect user interaction feedback; finally, feedback data is used to dynamically update a model and strategy parameters to form a closed-loop iterative optimization system, so that more accurate and scene-based game recommendation is realized.

Description

Technical Field

[0001] This invention relates to the field of data processing, and more specifically, to a method, apparatus, and readable storage medium for intelligent game recommendation on an Android emulator. Background Technology

[0002] With the widespread use of Android emulators on personal computers, running mobile games via emulators has become a mainstream method. However, most existing game recommendation systems are designed based on user behavior and general preferences on mobile devices, failing to fully consider the unique characteristics of the emulator environment. For example, key factors such as the user's computer hardware configuration, peripheral usage habits, multi-instance and AFK behavior, and the game's compatibility and optimization with the emulator are often overlooked, resulting in inaccurate recommendations. Furthermore, traditional recommendation methods lack the ability to dynamically render interfaces based on real-time user actions and struggle to utilize feedback data for rapid closed-loop iteration and optimization of the model. Therefore, there is an urgent need for a technical solution that can deeply understand the emulator environment and user behavior, providing highly personalized, context-based intelligent game recommendations. Summary of the Invention

[0003] The purpose of this invention is to provide a method, apparatus, and readable storage medium for intelligent game recommendation on an Android emulator.

[0004] In a first aspect, embodiments of the present invention provide an intelligent game recommendation method for Android emulators, comprising: Collect and calibrate emulator-specific behavioral characteristics, basic attribute data, in-game interaction behavior data, and game feedback data on the user side, as well as emulator adaptation attribute characteristics on the game side, to form a structured raw dataset. The structured raw dataset is processed to generate standardized user features and game features; Based on the aforementioned user features and game features, a user profile model and a game feature model are constructed, and corresponding user vectors and game vectors are generated. Based on the user vector and game vector, a cascaded filtering process of multi-way recall, coarse ranking, fine ranking and re-ranking is performed in sequence to generate a sorted list of game recommendation candidates; Based on the user's current simulator operation scenario, the sorted list of recommended game candidates is rendered and displayed in a personalized manner, and user interaction feedback data is collected. Based on the user interaction feedback data, the user vector, game vector, and strategy parameters used in the cascade filtering are dynamically updated, and the update results are applied in reverse to the feature processing and cascade filtering steps to form a closed-loop iteration.

[0005] In one possible implementation, the collection and calibration of user-side emulator-specific behavioral characteristics, basic attribute data, in-game interaction behavior data, and game feedback data, along with game-side emulator adaptation attribute characteristics, forms a structured raw dataset, including: Collect emulator-specific behavioral characteristics from the user side, including: user's computer hardware configuration level, peripheral device type, multi-instance behavior mode, percentage of idle time, and emulator function usage records. Collect basic attribute data, in-game interaction behavior data, and game feedback data from the user side; wherein, the basic attribute data includes age and / or gender; the in-game interaction behavior data includes in-game skill usage habit sequences and / or social interaction records; and the game feedback data includes ratings and / or text comments. Collect emulator adaptation attribute features from the game side. These emulator adaptation attribute features include: minimum configuration requirements for the game in the emulator environment, high frame rate adaptation flag, keyboard and mouse control adaptation flag, multi-instance operation adaptation flag, and emulator-specific benefit parameters. The collected simulator-specific behavioral features, basic attribute data, in-game interaction behavior data, game feedback data, and simulator adaptation attribute features are calibrated to form the structured raw dataset.

[0006] In one possible implementation, the execution of multiple recall includes: Based on the historical interaction matrix between users and games, the similarity between users or games is calculated for collaborative filtering and recall. Based on the simulator function scenarios activated by the user in real time and / or the current hardware load status, match and recall games that are suitable for the scenario or resource requirements. Content matching and recall are performed based on users’ keyboard and mouse operation habits and game keyboard and mouse control optimization tags, and / or content matching and recall are performed based on users’ multi-instance behavior and game multi-instance support tags. Incentives are used to drive user recall based on whether the game offers exclusive benefits to emulator users.

[0007] In one possible implementation, the fine sorting includes: Fine-grained user behavior sequence features, game configuration and user hardware compatibility scores, and welfare intensity features are input into a fine ranking model that integrates a deep interest network and a multi-objective optimization model. The refined ranking model simultaneously optimizes multiple objectives, including click-through rate, download conversion rate, user retention rate, and paid conversion rate, with different optimization weights assigned to different user groups for each objective.

[0008] In one possible implementation, dynamically updating the user vector, game vector, and strategy parameters used in the cascading filtering based on the user interaction feedback data includes: Update the user characteristics and game characteristics based on the user interaction feedback data; Based on the updated user features and game features, the user vector and game vector are regenerated. Based on the impact of the user interaction feedback data on the recommendation effect, the strategy parameters in the cascading filter are adjusted.

[0009] In one possible implementation, the feature processing of the structured raw dataset to generate standardized user features and game features includes: The multi-instance behavior mode, idle time ratio and simulator function usage records in the simulator-specific behavior features are converted into numerical feature vectors through one-hot encoding or embedded encoding. The minimum configuration requirements, high frame rate adaptation flags, keyboard and mouse control adaptation flags, and multi-instance operation adaptation flags in the emulator adaptation attribute features of the game side are standardized and binarized. Using sentiment analysis and topic extraction models in natural language processing, the collected text comments are analyzed to generate sentiment scores and topic distribution vectors. Clustering algorithms are used to cluster the skill usage habit sequences in the in-game interaction data to generate user behavior category labels representing different operation styles. The numerical feature vector, the encoded adaptive attribute features, the sentiment score and topic distribution vector, and the user behavior category label are fused to generate standardized user features and game features.

[0010] In one possible implementation, the step of personalizing the rendering and display of the sorted game recommendation candidate list based on the user's current simulator operation scenario, and collecting user interaction feedback data, includes: Identify the user's current emulator operation scenario, which includes at least one of the following: single-window keyboard and mouse operation scenario, multi-instance AFK scenario, and high frame rate competitive scenario; Based on the identified operation scenario, the corresponding interface layout template and recommendation card style are called from the preset template library. The interface layout template defines the container position, size and dynamic interaction area of ​​the recommendation information, and the recommendation card style defines the visual presentation rules of game icons, text descriptions, adaptation marks and operation guidance buttons. The game information in the sorted game recommendation candidate list is rendered according to the interface layout template and recommendation card style. Specifically, for keyboard and mouse operation scenarios, the rendering process highlights the game's keyboard and mouse control optimization indicator and the preset key operation guide entry. For multi-instance AFK scenarios, the rendering process highlights the game's multi-instance operation support indicator and real-time resource usage prompt. For high frame rate competitive scenarios, the rendering process highlights the game's high frame rate adaptation indicator and the current frame rate performance preview. The rendered personalized recommendations are dynamically displayed in a fixed recommendation area in the sidebar of the simulator's main interface or in a floating window control triggered by user actions, and the user's interaction events with the recommended content are listened to as user interaction feedback data.

[0011] Secondly, embodiments of the present invention provide an intelligent game recommendation device for an Android emulator, comprising: The acquisition module is used to collect and calibrate the user-side simulator-specific behavioral characteristics, basic attribute data, in-game interaction behavior data and game feedback data, as well as the game-side simulator adaptation attribute characteristics, to form a structured raw dataset. The recommendation module processes the structured raw dataset to generate standardized user and game features; it constructs user profile and game feature models based on these features, and generates corresponding user and game vectors; based on these user and game vectors, it sequentially performs cascaded filtering of multi-way recall, coarse ranking, fine ranking, and re-ranking to generate a sorted list of game recommendation candidates; it personalizes and displays the sorted list of game recommendation candidates according to the user's current simulator operation scenario, and collects user interaction feedback data; based on the user interaction feedback data, it dynamically updates the user vectors, game vectors, and strategy parameters used in the cascaded filtering, and applies the update results back to the feature processing and cascaded filtering steps to form a closed-loop iteration.

[0012] Thirdly, embodiments of the present invention provide a computer device, the computer device including a processor and a non-volatile memory storing computer instructions, wherein when the computer instructions are executed by the processor, the computer device performs the method described in the first aspect.

[0013] Fourthly, embodiments of the present invention provide a readable storage medium, the readable storage medium including a computer program, wherein the computer program, when running, controls the computer device where the readable storage medium is located to execute the method described in the first aspect.

[0014] Compared to existing technologies, the beneficial effects of this invention include: employing an intelligent game recommendation method, device, and readable storage medium for Android emulators disclosed in this invention, a structured dataset is formed by comprehensively collecting multi-dimensional feature data from both the user and the game. Standardized feature vectors for the user and the game are constructed through feature processing of the data. Based on these vectors, a cascaded filtering process of multi-path recall, coarse ranking, fine ranking, and re-ranking is used to generate a sorted recommendation list. This method can personalize the rendering and display of recommendation results according to the user's real-time emulator operation scenario and collect user interaction feedback. Finally, the model and strategy parameters are dynamically updated using the feedback data, forming a closed-loop iterative optimization system, thereby achieving more accurate and scenario-based game recommendations. Attached Figure Description

[0015] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the embodiments will be briefly described below. It should be understood that the following drawings only show some embodiments of the present invention and should not be considered as limiting the scope. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0016] Figure 1 This is a flowchart illustrating the steps of the Android emulator game intelligent recommendation method provided in an embodiment of the present invention.

[0017] Figure 2 A schematic block diagram of the structure of the Android emulator game intelligent recommendation device provided in the embodiments of the present invention;

[0018] Figure 3 A schematic block diagram of the structure of a computer device provided in an embodiment of the present invention. Detailed Implementation

[0019] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some, not all, of the embodiments of the present invention. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0020] The specific embodiments of the present invention will now be described in detail with reference to the accompanying drawings.

[0021] In order to solve the technical problems mentioned in the background art Figure 1 This is a flowchart illustrating the intelligent game recommendation method for Android emulators provided in this embodiment. The method will now be described in detail.

[0022] Step S201: Collect and calibrate the simulator-specific behavioral features, basic attribute data, in-game interaction behavior data and game feedback data on the user side, as well as the simulator adaptation attribute features on the game side, to form a structured raw dataset.

[0023] The server initiates the data collection process. First, the server uses a data collection SDK deployed on the user's Android emulator client to collect real-time emulator-specific behavioral characteristics from the user's side. For example, the server collects data showing that user "User A's" computer hardware configuration is "mid-to-high-end (CPU i7, GPU RTX 3060, 16GB RAM)," their commonly used peripherals are "mechanical keyboard and gaming mouse," their multi-account behavior pattern is "running 3 accounts overnight," their average daily AFK time is "40%," and their frequent use of the emulator's "one-click macro recording" and "high frame rate mode" functions. This data is packaged into logs and reported to the server.

[0024] Simultaneously, the server retrieves basic attribute data for "User A" from the user registration information database, such as age "25 years old" and gender "male". The server also synchronizes "User A's" interactive behavior data within the installed game "Game X" from the game operations backend via an interface, including the skill combination sequence "Skill Q-Skill W-Skill E" used frequently over a week, as well as their chat frequency and team-up records in the game guild. Furthermore, the server retrieves "User A's" rating of "4.5 stars" for "Game Y" and their text comment "Playing with a keyboard and mouse feels great, much better than on a mobile phone" from the emulator's built-in game center module.

[0025] On the game side, the server maintains a game feature library, which stores the emulator adaptation attributes of each game. For example, for "Game Z", the server records its minimum configuration requirements in the emulator environment as "CPU i5, GPU GTX1050, 8GB RAM", it has a "high frame rate adaptation mark (supports 120 frames per second)", has a "keyboard and mouse control adaptation mark (official preset key bindings)", supports "multi-instance operation adaptation mark (stable multi-instance operation)", and provides emulator users with an "exclusive login bonus package".

[0026] After receiving all the raw data, the server performs a calibration operation. Calibration includes standardizing the timestamps of all data to UTC, filling the missing "Peripheral Type" field with the default value "Keyboard and Mouse Set," removing abnormal negative values ​​from the "AFK Time Percentage," and performing preliminary word segmentation and cleaning on unstructured text comments such as "Feels great...". After calibration, the server integrates data from different sources and formats into structured records indexed by "User ID," "Game ID," and "Timestamp," storing these records in a distributed database (such as a Hive table) to form a structured raw dataset suitable for subsequent analysis.

[0027] Step S202: Perform feature processing on the structured raw dataset to generate standardized user features and game features; The server initiates a feature processing pipeline. For user "User A's" emulator-specific behavioral features, the server uses one-hot encoding to transform their "multi-account behavior pattern" (running 3 accounts overnight) into a sparse vector, such as [0,1,0,0], where each position represents a preset mode (e.g., "single account", "dual account", "triple account", "quadruple account and above"). Simultaneously, the "percentage of time spent running the emulator (40%)" and the frequency of use of various emulator functions (e.g., "one-click macro recording: 5 times per day") are directly normalized as continuous features.

[0028] For the emulator compatibility attributes of the game "Game Z", the server compares its "minimum configuration requirements" with the "hardware configuration level" of user "User A" to generate a "configuration compatibility score" (e.g., 0.9, indicating that the user's hardware far exceeds the game's requirements). Boolean features such as "high frame rate compatibility flag", "keyboard and mouse control compatibility flag", and "multi-instance operation compatibility flag" are binarized and encoded (1 indicates support, 0 indicates no support).

[0029] For the collected text comments, the server calls a pre-trained natural language processing model. First, a sentiment analysis model is used to analyze the comment "The keyboard and mouse feel great to play with...", outputting a sentiment score of 0.85 (positive). Then, a topic extraction model (such as LDA) is used to extract topics such as "operation experience", "screen smoothness", and "promotional activities" from a large number of comments, and the comment is transformed into a topic distribution vector, for example [0.7, 0.2, 0.1], indicating that 70% of its content is related to "operation experience".

[0030] For user "User A" in Game X, the skill usage sequence is "Skill Q-Skill W-Skill E". The server uses the K-means clustering algorithm to cluster the skill sequences of all users. Assuming that three categories are clustered: "Aggressive Combo Type", "Conservative Defense Type", and "Roaming Support Type", the server finds that "User A's" sequence is classified as "Aggressive Combo Type", and thus generates an "Operation Style Label" for him.

[0031] Finally, the server concatenates and merges all the features obtained from the above processing, including numerical feature vectors, binarized adaptation tags, sentiment scores, topic vectors, and operation style labels, according to a predefined field order. For the user side, a standardized user feature vector representing "User A" is generated, containing multi-dimensional information such as hardware, behavior, and preferences. For the game side, a standardized game feature vector representing "Game Z" is generated, containing multi-dimensional information such as configuration requirements, adaptation characteristics, and reputation. These feature vectors are all scaled to the same numerical range to facilitate subsequent model processing.

[0032] Step S203: Construct a user profile model and a game feature model based on the user features and game features, and construct corresponding user vectors and game vectors; The server loads the standardized features output from the feature processing stage. To build deeper representations, the server inputs user features and game features into two separate deep learning models.

[0033] For user features, the server uses a user profiling model, which can be a multilayer perceptron (MLP) or a neural network with an attention mechanism. The model takes the normalized feature vector of "User A" as input, passes it through several hidden layers of nonlinear transformation, and finally obtains a low-dimensional, dense user vector (UserEmbedding) at the output layer, such as a 128-dimensional vector U_A. This vector U_A is an abstract and compressed representation of all the user's original features, enabling more efficient capture of the user's core interests and state.

[0034] Similarly, for game features, the server uses a game feature model, the structure of which may be similar to or different from the user model. This model takes the standardized feature vector of "Game Z" as input, calculates it, and outputs a game vector (ItemEmbedding) of the same dimension, such as I_Z. Vector I_Z comprehensively expresses the game's core attributes such as adaptability in the simulator environment, gameplay characteristics, and popularity.

[0035] The server periodically (e.g., daily) trains or fine-tunes these two models using the latest feature data to ensure that the generated user vectors and game vectors reflect the latest user behavior and game ecosystem. After training, the server stores the vectors U of all current active users and the vectors I of all games in a high-performance vector database (such as Milvus or Faiss) for quick retrieval in subsequent recommendation retrieval steps.

[0036] Step S204: Based on the user vector and game vector, perform cascaded filtering of multi-way recall, coarse ranking, fine ranking and re-ranking in sequence to generate a sorted list of game recommendation candidates; When the server needs to generate recommendations for "User A", the cascading filtering process is initiated.

[0037] 1. Multi-channel recall: The server starts multiple recall channels in parallel to quickly screen out hundreds of candidate games from the full game library.

[0038] Collaborative filtering recall: The server calculates the cosine similarity between user vector U_A and all other user vectors to find the most similar "neighbor users" group. Then, it recalls games that these neighbor users like but "user A" has not played (such as "Game M"). At the same time, it also calculates the similarity of game vector I_Z and performs item-based collaborative filtering recall.

[0039] Scene-matched recall: The server receives real-time reports from client "User A" and discovers that "High Frame Rate Mode" is currently active and the GPU load is low. The server then searches the game feature database for all games with "High Frame Rate Adaptation Tags" and whose configuration requirements match the current hardware load (such as "Game N"), and recalls them.

[0040] Content-matched recall: Based on "User A's" "keyboard and mouse operation habits" tag, the server recalls all games with a "keyboard and mouse control compatibility tag" and whose official preset key bindings match User A's habits. Simultaneously, based on User A's "multi-instance behavior pattern," the server recalls all games that support the "multi-instance operation compatibility tag."

[0041] Incentive-driven recall: The server recently recalled the game "Game P", which offered high-value "exclusive benefits" (such as rare item packs for new users) to emulator users.

[0042] 2. Coarse Ranking: After merging the hundreds of candidate games obtained in the recall phase and removing duplicates, they enter the coarse ranking phase. The server uses a lightweight model (such as logistic regression or a shallow neural network) to initially score each candidate game. This model considers relatively few features, such as mainly calculating the inner product of the user vector U_A and each candidate game vector I (as a rough estimate of interest matching), combined with simple features such as the game's real-time popularity and incentive level. Based on the scores, the server quickly selects the top 100 games with the highest scores for fine ranking.

[0043] 3. Fine-grained Ranking: This is the core ranking step of the recommendation system. The server inputs hundreds of features, including fine-grained user behavior sequence features of "User A" (such as the sequence of recently clicked game categories), detailed configuration suitability scores for game "Game Z," and features related to exclusive benefits, into a complex fine-grained ranking model. This model is a deep network that integrates Deep Interest Network (DIN) and Multi-Task Learning (MMoE). The DIN part is used to capture the dynamic relationship between user interests and candidate games; the MMoE part simultaneously optimizes four objectives: Click-through rate (CTR), Conversion Rate (CVR), User Retention, and Payment Rate. Based on the user group to which "User A" belongs (such as "young, hardcore, and with a high willingness to pay"), the server assigns specific optimization weights (e.g., payment weight is greater than click weight) to these four objectives within the model. The model ultimately outputs a comprehensive predicted score for these 100 candidate games and performs a rigorous ranking based on this score, resulting in a fine-grained list of the top 20 games.

[0044] 4. Reordering: Before the final display, the server reorders the refined list according to business rules and for greater diversity. For example, the server might apply a "dispersion strategy" to avoid games from the same developer appearing consecutively; a "freshness strategy" to appropriately promote a high-quality but newly released emulator-compatible game; or insert an "exploration slot" to recommend a game that differs significantly from "User A's" historical interests but is a good fit, in order to explore their potential interests. After reordering, the server generates a final ranked list of game recommendations, which can contain 10-15 games.

[0045] Step S205: Based on the current simulator operation scenario of the user, the sorted game recommendation candidate list is rendered and displayed in a personalized manner, and user interaction feedback data is collected.

[0046] The server sends the final sorted list to "User A's" emulator client, along with rendering instructions. The client first identifies the current operating scenario: assuming "User A" is running a competitive game in a single window in full-screen mode, the client identifies this scenario as a "single-window keyboard and mouse operation scenario".

[0047] The client retrieves the corresponding interface layout template and recommended card styles from its local machine or the server based on the scene identifier (such as "scene_keymouse") sent by the server. For keyboard and mouse operation scenarios, the template may specify that the recommended content is displayed in a compact vertical list format on the right edge of the game window (sidebar). The card styles specify that each game needs to highlight its "Keyboard and Mouse Control Optimized" label and provide a "View Keyboard Guide" button below the description text.

[0048] The client renders the game information in the list based on templates and styles. For example, for "Game Z," which supports official keyboard and mouse compatibility, its card will highlight a keyboard and mouse icon and render the text "Official Preset Keys." After rendering, the client dynamically displays this personalized recommendation in the right sidebar of the game window.

[0049] Once User A sees the recommendation, any interaction they make—such as hovering the mouse over the "Game Z" card, clicking "View Key Guide," or directly clicking the download button—will be monitored by the client and reported back to the server in real time as user interaction feedback data. This data includes: exposure logs, click logs, download start / completion logs, and page dwell time.

[0050] Step S206: Based on the user interaction feedback data, dynamically update the user vector, game vector, and strategy parameters used in the cascade filtering, and apply the update results in reverse to the feature processing and cascade filtering steps to form a closed-loop iteration.

[0051] The server continuously receives interactive feedback data streams from "User A" and a massive number of other users. This data is first used to dynamically update user profiles. For example, if "User A" clicks on the recommendation for "Game Z," this action will immediately update their "Recent Click Sequence" profile; if they complete the download and launch the game, their "Game Library" profile will be updated; if they make in-game purchases, their "Paying Ability" tag will be enhanced.

[0052] Based on the updated features, the server can trigger incremental updates to the user profile model and game feature model in near real-time (through online learning) or periodically (through daily offline training), thereby generating updated user vectors U_A' and game vectors I_Z'. These new vectors can more accurately reflect the user's latest interests and the latest state of the game.

[0053] Simultaneously, the server analyzes global recommendation performance metrics (such as a decrease in overall click-through rate or an increase in download conversion rate for a particular game type) to adjust strategy parameters in cascading filtering. For example, in a multi-objective model during the fine-tuning phase, the server might detect that the weight of the "user retention rate" objective needs to be increased overall, and thus adjust the weight coefficient of that objective in the loss function during the next training iteration of the model. During the re-ranking phase, the server might adjust the frequency of "exploration positions" or the strength of "scattering rules" based on A / B test results.

[0054] These updates, including new features, new vectors, and new model parameters, will be immediately or in the next recommendation cycle applied in reverse to the feature processing pipeline in step two and the cascaded filtering process in step four. For example, updated vectors are used for recall and coarse ranking, while the optimized fine-ranking model is used for scoring. This forms a closed-loop iterative system from "data collection" → "feature processing" → "model building and ranking" → "display and feedback" → "model / strategy update" → back to "feature processing" and "ranking". This system can continuously evolve with user behavior and data accumulation, making game recommendations increasingly accurate and personalized.

[0055] In this embodiment of the invention, the process of collecting and calibrating the user-side simulator-specific behavioral features, basic attribute data, in-game interaction behavior data, and game feedback data, as well as the game-side simulator adaptation attribute features, to form a structured raw dataset can be implemented through the following examples.

[0056] Collect emulator-specific behavioral characteristics from the user side, including: user's computer hardware configuration level, peripheral device type, multi-instance behavior mode, percentage of idle time, and emulator function usage records.

[0057] Collect basic attribute data, in-game interaction behavior data, and game feedback data from the user side; wherein, the basic attribute data includes age and / or gender; the in-game interaction behavior data includes in-game skill usage habit sequences and / or social interaction records; and the game feedback data includes ratings and / or text comments.

[0058] Collect emulator adaptation attribute features from the game side. These emulator adaptation attribute features include: minimum configuration requirements for the game in the emulator environment, high frame rate adaptation flag, keyboard and mouse control adaptation flag, multi-instance operation adaptation flag, and emulator-specific benefit parameters.

[0059] The collected simulator-specific behavioral features, basic attribute data, in-game interaction behavior data, game feedback data, and simulator adaptation attribute features are calibrated to form the structured raw dataset.

[0060] In this embodiment of the invention, for example, the server initiates a data acquisition task. On the user side, the server periodically or event-triggeredly collects emulator-specific behavioral characteristics through a data acquisition agent integrated into the Android emulator client. For example, the server receives a reported data packet from the user terminal "User_001", parses it, and obtains the user's computer hardware configuration information: CPU is Intel Core i7-12700H, GPU is NVIDIA GeForce RTX 3060 Laptop GPU, and memory is 16GB DDR5. The server classifies this configuration as "high-end" according to a preset hardware performance scoring rule. At the same time, the data packet contains the peripheral information connected to the user. The server identifies "mechanical keyboard (brand X model)" and "gaming mouse (brand Y model)" and records them as "peripheral type: high-performance keyboard and mouse set". The server also analyzes the user's emulator running logs over the past week, and statistically analyzes that the user's main multi-instance behavior pattern is "fixed three-instance AFK running on weekdays and nights", and calculates that the time spent in "AFK" (i.e., no active input) accounts for approximately 35% of the user's total emulator running time. In addition, the server recorded in detail the user's usage of the emulator's built-in functions, such as "high frame rate mode is used for an average of 4.2 hours per day", "one-click macro recording function is used 15 times per week", and "multi-instance synchronous operation function is used frequently".

[0061] Meanwhile, the server retrieved basic attribute data for user "User_001" from the user account center database, including the age "28 years old" and gender "male" entered during registration. The server also obtained in-depth interaction data of this user in the installed game "A Certain Competitive Battle Game G" through the game operation data interface. Specifically, the server analyzed the user's skill release logs from the last 100 matches, extracting the user's most frequently used combo sequence as "Skill A → Skill B → Enhanced Basic Attack → Skill C". The server also retrieved the user's in-game social interaction records, including joining the guild "Starry Sea" in the last 30 days, teaming up with a fixed teammate "Player_002" for 25 dungeon challenges, and averaging 10 messages per day in the guild channel. The server also scraped feedback data generated by the user from the emulator's built-in game community module, such as the user giving the game "A Certain Simulation Management Game H" a 4-star rating (out of 5 stars) and posting a text comment: "It's very convenient to let the game run in the background on the computer, and managing multiple farms is very efficient."

[0062] On the game side, the server maintains and updates a central game feature database. For each game, such as the newly launched "A Survival Adventure Game I", the server obtains its compatibility attributes in the emulator environment from its developer or through automated testing. The server records the minimum configuration requirements for the game to run smoothly on the emulator as "CPU: Intel i5-8300H equivalent or higher; GPU: NVIDIA GTX1060 equivalent or higher; Memory: 8GB". Through technical testing, the server marks the game with "High frame rate compatibility: Yes (supports 90 / 120 FPS)", "Keyboard and mouse control compatibility: Yes (provides official preset key mapping scheme)", and "Multi-instance compatibility: Yes (stable support for 3 instances after stress testing)". In addition, the server extracts "emulator-exclusive benefit parameters" prepared for emulator users from the operation activity configuration database, such as "Exclusive gift code: contains 1 rare weapon skin and 20,000 gold coins".

[0063] After aggregating all the raw data from the user and game sides, the server immediately executes a data calibration process. Calibration begins with time alignment, converting all behavior log timestamps to the server's local time (UTC+8). For outliers in the "AFK time percentage" field reported by user "User_001" (such as 150% reported due to client error), the server performs logical verification and removal based on normal data from the preceding and following time periods and hardware load logs. For missing "peripheral device type" information for some users, the server fills it with the default value "standard keyboard and mouse" based on their historical records or common configurations of users with similar hardware. For text comments like "It's very convenient to AFK farm on the computer...", the server calls natural language processing services to clean the comments, removing irrelevant characters and performing word segmentation to obtain valid word sequences such as "computer," "AFK," "farm," "convenient," "multi-instance," "farm," "efficiency," and "high."

[0064] After calibration, the server assembles this heterogeneous data according to a predefined structured format. For example, a user behavior record is generated with the primary key (UserID:User_001, GameID: a simulation game H, Timestamp: 2023-10-27 22:15:30), and its fields include the calibrated hardware level, peripheral type, rating (4), and a list of segmented comments. All such records are batch-written into a designated table in a distributed data warehouse (such as Hive). This table has a clear schema definition, and the type and meaning of each field are strictly standardized, thus forming a high-quality structured raw dataset that can be directly consumed in the subsequent feature engineering stage.

[0065] In this embodiment of the invention, the execution of multiple recall can be implemented through the following examples.

[0066] Based on the historical interaction matrix between users and games, the similarity between users or games is calculated for collaborative filtering and recall. Based on the simulator function scenarios activated by the user in real time and / or the current hardware load status, match and recall games that are suitable for the scenario or resource requirements. Content matching and recall are performed based on users’ keyboard and mouse operation habits and game keyboard and mouse control optimization tags, and / or content matching and recall are performed based on users’ multi-instance behavior and game multi-instance support tags. Incentives are used to drive user recall based on whether the game offers exclusive benefits to emulator users.

[0067] In this embodiment of the invention, for example, the server first performs collaborative filtering recall. The server loads the historical interaction behavior matrix of user "User_001" with all games (including the weights of behaviors such as clicks, downloads, and payments). Through vectorization calculation, it is found that the cosine similarity between the user's behavior vector and that of user "User_005" is as high as 0.92. The server then queries the list of games recently downloaded and highly rated by user "User_005", and adds the tactical competitive game "A Certain Tactical Competitive Shooting Game C", which "User_001" has not yet played, to the recall set. At the same time, the server also calculates the similarity between games. Based on the game vector of "A Certain Competitive Battle Game G", which "User_001" has played extensively, it finds a game with similar gameplay and adapted to the emulator, "A Certain Multiplayer Online Tactical Competitive Game B", and recalls it as well.

[0068] Secondly, the server performs scene matching and recall. The server receives real-time system status reports from the "User_001" client. The data indicates that the user has currently activated the emulator's "high frame rate mode," and real-time hardware monitoring shows that GPU utilization is only 45%, with sufficient memory. The server immediately searches its game feature library for all games marked as "high frame rate compatible" and whose "minimum configuration requirements" are lower than the current available hardware resources. For example, the server matches a visually appealing open-world game, "A Certain Open World Role-Playing Game," which supports 120 frames per second, and recalls it to meet the user's real-time demand for a high-quality, smooth experience.

[0069] Next, the server performs content matching and recall. The server queries the user feature database to obtain long-term behavioral tags for "User_001," including "preference for precise keyboard and mouse operation" and "habit of running multiple instances of the game." The server then performs bidirectional matching in the game feature database: on one hand, it recalls all games marked with "optimized keyboard and mouse control" and offering complex skill key presets, such as *A Certain First-Person Shooter Game D*; on the other hand, it recalls all games marked with "support for running multiple instances" and with relatively mild system resource consumption, such as *A Certain Idle Game E*. These two sets of results are then merged into the recall set.

[0070] Finally, the server executes an incentive-driven recall. The server scans a game operation characteristic table, filters out games that have recently set high-value "exclusive benefit parameters" for emulator users, and sorts them according to the strength of the benefits (such as the value of the gift pack and its rarity). For example, if the server discovers that a new game, "A Certain Sci-Fi Role-Playing Game F," is running an emulator-exclusive event with a benefit strength parameter score of 95 out of 100, it will add it to the recall set to leverage the incentive to increase users' willingness to try the game.

[0071] After completing the above four parallel recall channels, the server merges and deduplicates the game ID lists generated by each channel to create a preliminary candidate game pool that covers multiple dimensions such as similar interests, scene fit, content matching, and incentive attraction, for subsequent coarse ranking stage processing.

[0072] In this embodiment of the invention, the fine sorting can be implemented through the following examples.

[0073] Fine-grained user behavior sequence features, game configuration and user hardware compatibility scores, and welfare intensity features are input into a fine ranking model that integrates a deep interest network and a multi-objective optimization model. The refined ranking model simultaneously optimizes multiple objectives, including click-through rate, download conversion rate, user retention rate, and paid conversion rate, with different optimization weights assigned to different user groups for each objective.

[0074] In this embodiment of the invention, for example, firstly, the server extracts fine-grained features for ranking from the feature library. For the user side, the server obtains the game ID sequence [Game_A, Game_B, Game_C] clicked by "User_001" in the last 24 hours, its detailed skill release sequence feature vector in a competitive game (G), and its real-time hardware status (e.g., 6GB of remaining GPU memory). For each candidate game, such as an open-world role-playing game (A), the server calculates its "configuration and user hardware compatibility score": comparing the game's minimum configuration requirement (GTX1060) with the user's current hardware (RTX3060), and combining this with a real-time resource usage model, a compatibility score of 0.95 (out of 1) is obtained. Simultaneously, the server extracts the game's "emulator-specific welfare strength feature," calculating a welfare attractiveness score of 85 points based on the value and scarcity of the gift packs.

[0075] Next, the server inputs these multidimensional features (user behavior sequences, real-time status, game suitability, incentive levels, etc.) into a fine-grained ranking model deployed on a GPU cluster. This model is an architecture that integrates Deep Interest Network (DIN) and Multi-Task Learning (MMoE). The DIN component specifically processes the user's historical behavior sequences. It uses an attention mechanism to calculate the dynamic relevance weights between the historical click sequences of "User_001" and the current candidate game, "A Certain Open-World Role-Playing Game A," thereby capturing its instantaneous interest shifts. The MMoE component contains multiple expert networks and task towers, and simultaneously makes independent predictions for four objectives for "A Certain Open-World Role-Playing Game A": Click-Through Rate (CTR), Download Conversion Rate (CVR), 7-Day Retention Rate, and First-Week Payment Rate.

[0076] Based on the user profile tags of "User_001" ("hardcore gamer", "high spending potential"), the server assigns different optimization weights to these four objectives during model inference. Specifically, the model sets the weight vector for this user group as [0.2, 0.3, 0.3, 0.2], meaning it focuses more on download conversion and long-term retention, rather than simply clicks. After comprehensively calculating the weights of all features and objectives, the model outputs the final predicted comprehensive score S_a_open-world role-playing game A = 0.92.

[0077] The server performs the above calculations on all 100 candidate games, obtaining a comprehensive score for each game, and then strictly sorts them from highest to lowest score. Finally, the server generates a finely ranked list of 20 games, which is submitted to the subsequent re-ranking stage for diversity adjustments.

[0078] In an embodiment of the present invention, the dynamic update of the user vector, game vector, and the policy parameters used in cascade filtering according to the user interaction feedback data can be implemented through the following examples.

[0079] Update the user features and game features according to the user interaction feedback data; Based on the updated user features and game features, regenerate the user vector and game vector; Adjust the policy parameters in the cascade filtering according to the impact of the user interaction feedback data on the recommendation effect.

[0080] In an embodiment of the present invention, for example, the process in which the server performs dynamic update to form a recommendation closed-loop is a continuous learning and adjustment loop. When the server receives the interaction feedback data generated by "User_001" for the recommended game "An Open World Role-Playing Game A", including the exposure log, the detail page stay log exceeding 3 seconds, and the final download completion log, the update process is immediately initiated.

[0081] First, the server updates the user features and game features. On the user side, the server immediately appends the browsing and download events of "An Open World Role-Playing Game A" to the "recent behavior sequence" feature of "User_001" and updates its "game library" feature. At the same time, this download behavior slightly increases the label weight of its "preference for high-quality open world games". On the game side, the server updates the global statistical features of "An Open World Role-Playing Game A", such as increasing the download counter and updating the statistic of "downloaded by users with high hardware configuration" associated with this user.

[0082] Subsequently, the server regenerates the user vector and game vector. Based on the updated features, the server triggers the online incremental update of the user portrait model and the game feature model. The model (such as FTRL using an online learning mechanism) uses this batch of new positive sample (download) data to fine-tune its internal parameters. After a few minutes, the server generates a new user vector U_001_v2 for "User_001" that reflects its latest interest state, and also generates a game vector I_An Open World Role-Playing Game A_v2 for "An Open World Role-Playing Game A" that contains the latest download popularity information. These new vectors are updated to the vector retrieval library in real time.

[0083] Finally, the server adjusts the strategy parameters in the cascading filtering. The system analyzes the feedback chain of "User_001" (exposure → deep browsing → download) and subsequent data such as whether the game was successfully launched and whether payment was made, to evaluate the overall effectiveness of this recommendation. Simultaneously, the server aggregates and analyzes massive amounts of feedback data from similar users, discovering that the user retention rate of games based on the "high frame rate mode" scenario recall in the recent "scenario matching recall" channel has generally increased by 15%. Based on this insight, the server automatically adjusts the global weight coefficient of the "retention rate" objective in the multi-objective model during the fine-tuning stage, increasing it from 0.25 to 0.30, and simultaneously adjusts the trigger threshold of scenario matching recall, making it more proactive in recommending high frame rate compatible games when hardware resources allow. These updated model parameters and strategy rules will take effect immediately when generating recommendations for "User_001" and other users, thus completing a full closed-loop iteration from data feedback to model strategy optimization.

[0084] In this embodiment of the invention, the step of processing the structured original dataset to generate standardized user features and game features can be implemented through the following example.

[0085] The multi-instance behavior mode, idle time ratio and simulator function usage records in the simulator-specific behavior features are converted into numerical feature vectors through one-hot encoding or embedded encoding. The minimum configuration requirements, high frame rate adaptation flags, keyboard and mouse control adaptation flags, and multi-instance operation adaptation flags in the emulator adaptation attribute features of the game side are standardized and binarized. Using sentiment analysis and topic extraction models in natural language processing, the collected text comments are analyzed to generate sentiment scores and topic distribution vectors. Clustering algorithms are used to cluster the skill usage habit sequences in the in-game interaction data to generate user behavior category labels representing different operation styles. The numerical feature vector, the encoded adaptive attribute features, the sentiment score and topic distribution vector, and the user behavior category label are fused to generate standardized user features and game features.

[0086] In this embodiment of the invention, for example, firstly, the server processes the emulator-specific behavioral features on the user side. For the record of user "User_001", the server encodes its "multi-instance behavior mode". Based on a preset classification (e.g., ["single-instance", "dual-instance", "triple-instance", "quadruple-instance and above"]), its "fixed triple-instance AFK on weekdays and nights" mode is converted into a one-hot encoded vector [0,0,1,0]. Its "AFK time percentage 35%" is treated as a continuous value and normalized to the [0,1] interval, yielding a value of 0.35. In its "emulator function usage record", "average daily high frame rate mode usage time 4.2 hours" is divided by the maximum possible value (e.g., 24 hours) to obtain 0.175, and "one-click macro recording usage times 15 times per week" is converted into an embedded vector through bucketing (e.g., 0 times, 1-5 times, 6-20 times, and more than 20 times). These operations transform categorized and non-standardized behavioral data into a unified numerical feature vector.

[0087] Secondly, the server processes the emulator adaptation attributes of the game. For the game "A Survival Adventure Game I", the server compares its "minimum configuration requirements" (CPU i5-8300H, GTX1060) with a standard hardware performance benchmark library, and calculates the standardized performance scores of the CPU and GPU respectively (e.g., i5-8300H score 0.65, GTX1060 score 0.60), as two independent continuous features. At the same time, its Boolean features such as "high frame rate adaptation flag (yes)", "keyboard and mouse control adaptation flag (yes)", and "multi-instance running adaptation flag (yes)" are directly binarized and encoded into feature values ​​such as [1,1,1].

[0088] Next, the server processes the text feedback data. The server calls a sentiment analysis model deployed in the NLP service cluster to analyze user "User_001's" comment, "It's very convenient to leave the game running in the background, and managing multiple farms simultaneously is highly efficient." The model outputs a sentiment score of 0.8 (positive) for this comment. Simultaneously, the server calls a topic extraction model (such as LDA), which has been trained on massive amounts of game reviews and can identify topics such as "ease of operation," "efficiency of running multiple instances," "graphics," and "social interaction." This comment is transformed by the model into a topic distribution vector, for example, [0.6, 0.3, 0.05, 0.05], indicating that 60% of its content is related to "ease of operation" and 30% is related to "efficiency of running multiple instances."

[0089] Next, the server analyzes in-game interactions to generate style tags. The server collects all user micro-operation sequences similar to "Skill A → Skill B → Enhanced Basic Attack → Skill C" and analyzes them using a K-means clustering algorithm. The algorithm identifies three main categories, and the server categorizes the sequence "User_001" into "Category 2". By analyzing the commonalities within this category, the server assigns an interpretable user behavior category label, such as "aggressive combo type".

[0090] Finally, the server performs feature fusion. The server creates a standardized user feature template with predefined field order. It concatenates all the above processing results for "User_001," including the one-hot encoded behavior pattern vector [0,0,1,0], the normalized AFK percentage (0.35), the function usage embedding vector, and the age (28, normalized), gender code 1, sentiment score (0.8), topic distribution vector [0.6,0.3,...], and operation style label 2 (also one-hot encoded) obtained from other data sources, into a long vector. All numerical features have previously been standardized to a similar numerical range using methods such as max-min scaling. Similarly, the server creates a game feature template for the game "A Survival Adventure Game I," concatenating its standardized configuration score [0.65,0.60], binarized adaptation label [1,1,1], global average sentiment score, topic distribution vector, etc. Ultimately, the server generates a standardized feature vector for each user and each game, with fixed dimensions, clear meaning, and uniform numerical range, and stores it in the feature database for direct use by subsequent user profile modeling and recommendation ranking models.

[0091] In this embodiment of the invention, the step of personalizing the rendering and display of the sorted game recommendation candidate list according to the user's current simulator operation scenario and collecting user interaction feedback data can be implemented through the following example.

[0092] Identify the user's current emulator operation scenario, which includes at least one of the following: single-window keyboard and mouse operation scenario, multi-instance AFK scenario, and high frame rate competitive scenario; Based on the identified operation scenario, the corresponding interface layout template and recommendation card style are called from the preset template library. The interface layout template defines the container position, size and dynamic interaction area of ​​the recommendation information, and the recommendation card style defines the visual presentation rules of game icons, text descriptions, adaptation marks and operation guidance buttons. The game information in the sorted game recommendation candidate list is rendered according to the interface layout template and recommendation card style. Specifically, for keyboard and mouse operation scenarios, the rendering process highlights the game's keyboard and mouse control optimization indicator and the preset key operation guide entry. For multi-instance AFK scenarios, the rendering process highlights the game's multi-instance operation support indicator and real-time resource usage prompt. For high frame rate competitive scenarios, the rendering process highlights the game's high frame rate adaptation indicator and the current frame rate performance preview. The rendered personalized recommendations are dynamically displayed in a fixed recommendation area in the sidebar of the simulator's main interface or in a floating window control triggered by user actions, and the user's interaction events with the recommended content are listened to as user interaction feedback data.

[0093] In this embodiment of the invention, the server's execution of personalized rendering and feedback collection is a crucial step connecting the recommendation algorithm and the user experience. This step is initiated immediately after the server completes the fine-grained and rearranged rankings and generates a final list of 10 game recommendation candidates for user "User_001".

[0094] First, the server identifies the user's current emulator operation scenario. The server receives real-time status heartbeat packets from the "User_001" emulator client. The heartbeat data indicates that: the current emulator has one running window, which is in full-screen focus; the client reports that "high frame rate mode (120Hz)" is activated; real-time hardware monitoring shows that GPU utilization has reached 78%, and the user is performing frequent keyboard and mouse operations (high IOPS). The server-side scene recognition engine comprehensively analyzes these signals and matches them as a "high frame rate competitive scenario."

[0095] Next, the server retrieves the corresponding interface layout template and recommendation card style. Based on the scene identifier "high_fps_competitive", the server searches its maintained rendering template library. The template library defines a SceneTemplate_HF for this scene: this template specifies that the recommendation information container is a semi-transparent floating panel, which by default attaches to the upper left corner of the game window, with a size of "400 pixels wide, height adaptive", and includes a draggable area and a dynamic button for expanding / collapsed recommendations. Simultaneously, the server retrieves the CardStyle_HF bound to this template: this style specifies the visual presentation rules for each game card, including using a large game icon (120x120 pixels), bold title font, mandatory display of the "high frame rate adaptation indicator" area, and a reserved entry point for a "frame rate preview" button.

[0096] Then, the server instructs the client to perform rendering. The server sends the sorted game list along with the template identifier SceneTemplate_HF and style identifier CardStyle_HF to the client "User_001". Upon receiving the instruction, the client begins rendering. For the first game in the list, "An Open-World Role-Playing Game A", the client fetches its icon and description text from its local cache or CDN. According to the CardStyle_HF rule, the client renders a dynamic "120FPS" badge in a prominent position on the card as a high frame rate adaptation identifier. Simultaneously, the client finds a pre-stored performance demo clip for this game locally and renders a "Real-time Frame Rate Preview" button on the card. For another game in the list that supports multiple instances, "An Idle Game E", although it is also in the list, in this scenario, the client, according to the style rules, will not highlight its multi-instance identifier but will only display it normally. The entire list is rendered as an interactive floating panel in the upper left corner of the game window, following the layout specified by the template.

[0097] Subsequently, the server dynamically displays and listens for interactions. The rendered personalized recommendation panel is displayed on the game interface of "User_001". When the user hovers the mouse over the "Frame Rate Preview" button of "A Certain Open World Role-Playing Game A", the client triggers a hover event; when the user clicks the button and watches a short video demonstrating the game running at a high frame rate on an emulator, the client triggers a click_preview event; finally, the user clicks the "One-Click Download" button below the card, the client triggers a click_download event and begins the download process. The client encapsulates these interaction events (including event type, target game ID, timestamp, dwell time, etc.) into logs in real time and reports them back to the server.

[0098] The server receives and parses these logs, storing them as valuable user interaction feedback data in the user behavior database. For example, a record might look like this: {user_id:“User_001”,game_id:“a certain open-world role-playing game A”,event:“click_download”,scene:“high_fps_competitive”,timestamp:“2023-10-27 22:30:15”}. This data will be directly used for subsequent user vector updates and recommendation strategy optimization, thus completing a closed loop from accurate recommendation to effect verification.

[0099] Please refer to the following: Figure 2 , Figure 2 An Android emulator game intelligent recommendation device 110 provided in this embodiment of the invention includes: The acquisition module 1101 is used to collect and calibrate the simulator-specific behavioral characteristics, basic attribute data, in-game interaction behavior data and game feedback data on the user side, as well as the simulator adaptation attribute characteristics on the game side, to form a structured raw dataset. The recommendation module 1102 is used to process the structured raw dataset to generate standardized user features and game features; construct a user profile model and a game feature model based on the user features and game features, and construct corresponding user vectors and game vectors; based on the user vectors and game vectors, perform cascaded filtering of multi-way recall, coarse ranking, fine ranking and re-ranking in sequence to generate a sorted game recommendation candidate list; according to the simulator operation scenario currently in which the user is, perform personalized rendering and display of the sorted game recommendation candidate list, and collect user interaction feedback data; according to the user interaction feedback data, dynamically update the user vectors, game vectors and the strategy parameters used in the cascaded filtering, and apply the update results back to the feature processing and cascaded filtering steps to form a closed loop iteration.

[0100] It should be noted that the implementation principle of the aforementioned Android emulator game intelligent recommendation device 110 can refer to the implementation principle of the aforementioned Android emulator game intelligent recommendation method, and will not be repeated here. It should be understood that the division of the various modules in the above device is merely a logical functional division; in actual implementation, they can be fully or partially integrated into a single physical entity, or physically separated. Furthermore, these modules can all be implemented in software through processing element calls; they can all be implemented in hardware; or some modules can be implemented by processing element calls to software, while others are implemented in hardware. For example, the Android emulator game intelligent recommendation device 110 can be a separately established processing element, or it can be integrated into a chip within the aforementioned device. Alternatively, it can be stored as program code in the memory of the aforementioned device, and called and executed by a processing element of the aforementioned device. The implementation of other modules is similar. Furthermore, these modules can be fully or partially integrated together, or implemented independently. The processing element described here can be an integrated circuit with signal processing capabilities. In the implementation process, each step of the above method or each of the above modules can be completed through integrated logic circuits in the hardware of the processor element or through software instructions.

[0101] For example, these modules can be one or more integrated circuits configured to implement the above methods, such as one or more application-specific integrated circuits (ASICs), one or more digital signal processors (DSPs), or one or more field-programmable gate arrays (FPGAs). As another example, when a module is implemented using processing element scheduler code, the processing element can be a general-purpose processor, such as a central processing unit (CPU) or other processor capable of calling program code. Furthermore, these modules can be integrated together to implement a system-on-a-chip (SOC).

[0102] This invention provides a computer device 100, which includes a processor and a non-volatile memory storing computer instructions. When the computer instructions are executed by the processor, the computer device 100 executes the aforementioned Android emulator game intelligent recommendation device 110. Figure 3 As shown, Figure 3 This is a structural block diagram of a computer device 100 provided in an embodiment of the present invention. The computer device 100 includes an Android emulator game intelligent recommendation device 110, a memory 111, a processor 112, and a communication unit 113.

[0103] To enable data transmission or interaction, the memory 111, processor 112, and communication unit 113 are electrically connected to each other directly or indirectly. For example, these components can be electrically connected to each other through one or more communication buses or signal lines. The Android emulator game recommendation device 110 includes at least one software function module that can be stored in the memory 111 or embedded in the operating system (OS) of the computer device 100 in the form of software or firmware. The processor 112 is used to execute the Android emulator game recommendation device 110 stored in the memory 111, such as the software function modules and computer programs included in the Android emulator game recommendation device 110.

[0104] This invention provides a readable storage medium, which includes a computer program. When the computer program runs, it controls the computer device where the readable storage medium is located to execute the aforementioned Android emulator game intelligent recommendation device 110.

[0105] For illustrative purposes, the foregoing description has been made with reference to specific embodiments. However, the foregoing illustrative discussions are not intended to be exhaustive or to limit the present disclosure to the precise forms disclosed. Numerous modifications and variations are possible in accordance with the foregoing teachings. These embodiments were chosen and described in order to best illustrate the principles of the present disclosure and its practical application, thereby enabling those skilled in the art to best utilize the disclosure and to employ various embodiments with different modifications to suit a particular intended application.

Claims

1. A method for intelligent game recommendation using an Android emulator, characterized in that, include: Collect and calibrate emulator-specific behavioral characteristics, basic attribute data, in-game interaction behavior data, and game feedback data on the user side, as well as emulator adaptation attribute characteristics on the game side, to form a structured raw dataset. The structured raw dataset is processed to generate standardized user features and game features; Based on the aforementioned user features and game features, a user profile model and a game feature model are constructed, and corresponding user vectors and game vectors are generated. Based on the user vector and game vector, a cascaded filtering process of multi-way recall, coarse ranking, fine ranking and re-ranking is performed in sequence to generate a sorted list of game recommendation candidates; Based on the user's current simulator operation scenario, the sorted list of recommended game candidates is rendered and displayed in a personalized manner, and user interaction feedback data is collected. Based on the user interaction feedback data, the user vector, game vector, and strategy parameters used in the cascade filtering are dynamically updated, and the update results are applied in reverse to the feature processing and cascade filtering steps to form a closed-loop iteration.

2. The method according to claim 1, characterized in that, The collection and calibration of user-side emulator-specific behavioral characteristics, basic attribute data, in-game interaction behavior data, and game feedback data, along with game-side emulator adaptation attribute characteristics, forms a structured raw dataset, including: Collect emulator-specific behavioral characteristics from the user side, including: user's computer hardware configuration level, peripheral device type, multi-instance behavior mode, percentage of idle time, and emulator function usage records. Collect basic attribute data, in-game interaction behavior data, and game feedback data from the user side; wherein, the basic attribute data includes age and / or gender; the in-game interaction behavior data includes in-game skill usage habit sequences and / or social interaction records; and the game feedback data includes ratings and / or text comments. Collect emulator adaptation attribute features from the game side. These emulator adaptation attribute features include: minimum configuration requirements for the game in the emulator environment, high frame rate adaptation flag, keyboard and mouse control adaptation flag, multi-instance operation adaptation flag, and emulator-specific benefit parameters. The collected simulator-specific behavioral features, basic attribute data, in-game interaction behavior data, game feedback data, and simulator adaptation attribute features are calibrated to form the structured raw dataset.

3. The method according to claim 1, characterized in that, The execution of multi-path recall includes: Based on the historical interaction matrix between users and games, the similarity between users or games is calculated for collaborative filtering and recall. Based on the simulator function scenarios activated by the user in real time and / or the current hardware load status, match and recall games that are suitable for the scenario or resource requirements. Content matching and recall are performed based on users’ keyboard and mouse operation habits and game keyboard and mouse control optimization tags, and / or content matching and recall are performed based on users’ multi-instance behavior and game multi-instance support tags. Incentives are used to drive user recall based on whether the game offers exclusive benefits to emulator users.

4. The method according to claim 1, characterized in that, The refined sorting includes: Fine-grained user behavior sequence features, game configuration and user hardware compatibility scores, and welfare intensity features are input into a fine ranking model that integrates a deep interest network and a multi-objective optimization model. The refined ranking model simultaneously optimizes multiple objectives, including click-through rate, download conversion rate, user retention rate, and paid conversion rate, with different optimization weights assigned to different user groups for each objective.

5. The method according to claim 1, characterized in that, The step of dynamically updating the user vector, game vector, and strategy parameters used in the cascading filtering based on the user interaction feedback data includes: Update the user characteristics and game characteristics based on the user interaction feedback data; Based on the updated user features and game features, the user vector and game vector are regenerated. Based on the impact of the user interaction feedback data on the recommendation effect, the strategy parameters in the cascading filter are adjusted.

6. The method according to claim 1, characterized in that, The step of processing the structured raw dataset to generate standardized user features and game features includes: The multi-instance behavior mode, idle time ratio and simulator function usage records in the simulator-specific behavior features are converted into numerical feature vectors through one-hot encoding or embedded encoding. The minimum configuration requirements, high frame rate adaptation flags, keyboard and mouse control adaptation flags, and multi-instance operation adaptation flags in the emulator adaptation attribute features of the game side are standardized and binarized. Using sentiment analysis and topic extraction models in natural language processing, the collected text comments are analyzed to generate sentiment scores and topic distribution vectors. Clustering algorithms are used to cluster the skill usage habit sequences in the in-game interaction data to generate user behavior category labels representing different operation styles. The numerical feature vector, the encoded adaptive attribute features, the sentiment score and topic distribution vector, and the user behavior category label are fused to generate standardized user features and game features.

7. The method according to claim 1, characterized in that, The process involves personalizing the rendering and display of the sorted game recommendation candidate list based on the user's current simulator operation scenario, and collecting user interaction feedback data, including: Identify the user's current emulator operation scenario, which includes at least one of the following: single-window keyboard and mouse operation scenario, multi-instance AFK scenario, and high frame rate competitive scenario; Based on the identified operation scenario, the corresponding interface layout template and recommendation card style are called from the preset template library. The interface layout template defines the container position, size and dynamic interaction area of ​​the recommendation information, and the recommendation card style defines the visual presentation rules of game icons, text descriptions, adaptation marks and operation guidance buttons. The game information in the sorted game recommendation candidate list is rendered according to the interface layout template and recommendation card style. Specifically, for keyboard and mouse operation scenarios, the rendering process highlights the game's keyboard and mouse control optimization indicator and the preset key operation guide entry. For multi-instance AFK scenarios, the rendering process highlights the game's multi-instance operation support indicator and real-time resource usage prompt. For high frame rate competitive scenarios, the rendering process highlights the game's high frame rate adaptation indicator and the current frame rate performance preview. The rendered personalized recommendations are dynamically displayed in a fixed recommendation area in the sidebar of the simulator's main interface or in a floating window control triggered by user actions, and the user's interaction events with the recommended content are listened to as user interaction feedback data.

8. An intelligent game recommendation device for Android emulators, characterized in that, include: The acquisition module is used to collect and calibrate the user-side simulator-specific behavioral characteristics, basic attribute data, in-game interaction behavior data and game feedback data, as well as the game-side simulator adaptation attribute characteristics, to form a structured raw dataset. The recommendation module processes the structured raw dataset to generate standardized user and game features; it constructs user profile and game feature models based on these features, and generates corresponding user and game vectors; based on these user and game vectors, it sequentially performs cascaded filtering of multi-way recall, coarse ranking, fine ranking, and re-ranking to generate a sorted list of game recommendation candidates; it personalizes and displays the sorted list of game recommendation candidates according to the user's current simulator operation scenario, and collects user interaction feedback data; based on the user interaction feedback data, it dynamically updates the user vectors, game vectors, and strategy parameters used in the cascaded filtering, and applies the update results back to the feature processing and cascaded filtering steps to form a closed-loop iteration.

9. A computer device, characterized in that, The computer device includes a processor and a non-volatile memory storing computer instructions. When the computer instructions are executed by the processor, the computer device performs the method according to any one of claims 1-7.

10. A readable storage medium, characterized in that, The readable storage medium includes a computer program, which, when executed, controls the computer device on which the readable storage medium is located to perform the method described in any one of claims 1-7.

Images