Individual console game archive recommendation method and device based on intelligent archive analysis

Abstract

The invention provides a console game archive personalized recommendation method and device based on intelligent archive analysis. The method comprises the following steps: positioning and reading an archived file of a console game, and executing archived format recognition and structured analysis operation on the archived file; performing text feature extraction based on the structured data set to generate a text feature vector; based on the text feature vector and the user portrait vector, calculating a difference degree value of each candidate archive relative to the target user by using a multi-dimensional difference measurement model; and sorting the candidate archives according to the difference degree values, generating an archive recommendation list, and issuing the archive recommendation list to the target user terminal. According to the method, unified analysis of heterogeneous archives can be realized, standardized progress and playing normal vector and difference measurement driven user portrait matching can be obtained, personalized archive recommendation can be realized, and the safety and reliability of cross-end synchronization can be improved.

Description

Technical Field

[0001] This application relates to the technical field of data processing, and in particular to a method and device for personalized recommendation of single-player game saves based on intelligent save parsing. Background Art

[0002] The progress of single-player games is usually saved in local save files. When players change devices, reinstall the system, or experience others' progress, they need to upload the saves to the cloud and synchronize them between different terminals. The existing solutions mainly fall into the following two categories: Built-in cloud save service of the platform: The game platform provides a basic backup function and only uploads and downloads saves in a file-by-byte comparison manner. Third-party save sharing communities: Some forums or network disks distribute saves in the form of attachments, and players manually download and overwrite the local files.

[0003] However, the above existing technologies still have the following defects: First, format heterogeneity is difficult to parse. The save structures of different games vary greatly. The existing services only perform file-level copying and cannot recognize the level, character, or item information contained in the saves.

[0004] Next, the ability to provide differentiated recommendations is lacking. Players can only filter saves by title or upload time and cannot obtain accurately matched save files based on their own game progress and play preferences.

[0005] Then, integrity and security are insufficient. Files are easily tampered with or damaged during the sharing process, and there is a lack of a unified hash check and rollback mechanism.

[0006] Finally, the lack of automatic management of cross-device consistency. The existing solutions mostly rely on manual overwriting of saves. If an operation error occurs, it is easy to cause progress loss, and the version cannot be maintained consistent among multiple terminals. Summary of the Invention

[0007] In view of this, the embodiments of this application provide a method and device for personalized recommendation of single-player game saves based on intelligent save parsing to solve the problems that existing heterogeneous saves are difficult to automatically parse, it is impossible to obtain unified progress and play characteristics, there is a lack of an accurate matching mechanism based on player portraits, it is difficult to recommend suitable saves, there is a lack of encryption and integrity verification, and the cross-terminal synchronization security is low.

[0008] In the first aspect of the embodiments of the present application, a method for personalized recommendation of single-player game saves based on intelligent save parsing is provided, including: locating and reading the save file of a single-player game, transmitting the save file to cloud storage via an encrypted link, and attaching integrity verification information during the upload process; when the cloud receives the save file, performing save format recognition and structured parsing operations on the save file to obtain a structured data set; extracting text features based on the structured data set to generate a text feature vector; collecting the historical game behavior data of a target user to generate a user portrait vector corresponding to the target user; for multiple candidate saves that have been parsed by the cloud, calculating the difference degree value of each candidate save relative to the target user by using a multi-dimensional difference metric model based on the text feature vector and the user portrait vector; sorting the candidate saves according to the difference degree value to generate a save recommendation list, and sending the save recommendation list to the target user terminal.

[0009] In the second aspect of the embodiments of the present application, a device for personalized recommendation of single-player game saves based on intelligent save parsing is provided, including: a transmission module for locating and reading the save file of a single-player game, transmitting the save file to cloud storage via an encrypted link, and attaching integrity verification information during the upload process; an analysis module for performing save format recognition and structured parsing operations on the save file to obtain a structured data set when the cloud receives the save file; an extraction module for extracting text features based on the structured data set to generate a text feature vector; a generation module for collecting the historical game behavior data of a target user to generate a user portrait vector corresponding to the target user; a calculation module for calculating the difference degree value of each candidate save relative to the target user by using a multi-dimensional difference metric model based on the text feature vector and the user portrait vector for multiple candidate saves that have been parsed by the cloud; a sorting module for sorting the candidate saves according to the difference degree value to generate a save recommendation list, and sending the save recommendation list to the target user terminal.

[0010] In the third aspect of the embodiments of the present application, an electronic device is provided, including a memory, a processor, and a computer program stored on the memory and executable on the processor, and the processor implements the steps of the above method when executing the computer program.

[0011] In the fourth aspect of the embodiments of the present application, a computer-readable storage medium is provided, and the computer-readable storage medium stores a computer program, and the computer program implements the steps of the above method when executed by a processor.

[0012] The above at least one technical solution adopted in the embodiments of the present application can achieve the following beneficial effects: By locating and reading the save files of single-player games, transmitting the save files to cloud storage via an encrypted link, and attaching integrity verification information during the upload process; when the cloud receives the save files, performing save format recognition and structured parsing operations on the save files to obtain a structured data set; extracting text features based on the structured data set to generate text feature vectors; collecting the historical game behavior data of the target user to generate a user portrait vector corresponding to the target user; for multiple candidate saves already parsed by the cloud, based on the text feature vectors and the user portrait vector, using a multi-dimensional difference metric model to calculate the difference degree values of each candidate save relative to the target user; sorting the candidate saves according to the difference degree values to generate a save recommendation list, and sending the save recommendation list to the target user terminal. This application can achieve unified parsing of heterogeneous saves, obtain standardized progress and gameplay vectors, user portrait matching driven by difference metrics, realize personalized save recommendations, and improve cross-terminal synchronization security and reliability. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following will briefly introduce the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings in the following description are only some embodiments of the present application. For those of ordinary skill in the art, without creative efforts, other drawings can also be obtained based on these drawings.

[0014] Figure 1 is a flowchart of a method for personalized recommendation of single-player game saves based on intelligent save parsing provided by an embodiment of the present application; Figure 2 is a structural diagram of a device for personalized recommendation of single-player game saves based on intelligent save parsing provided by an embodiment of the present application; Figure 3 is a structural diagram of an electronic device provided by an embodiment of the present application. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0015] In the following description, specific details such as specific system structures and technologies are presented for the purpose of illustration rather than limitation, so as to thoroughly understand the embodiments of the present application. However, those skilled in the art should clearly understand that the present application can also be implemented in other embodiments without these specific details. In other cases, detailed descriptions of well-known systems, devices, circuits, and methods are omitted to avoid unnecessary details from interfering with the description of the present application.

[0016] To solve the problem of cloud save synchronization function for single-player games / synchronizing one's own or using others', the present application provides a technical solution for save distribution technology - save parsing based on personalized recommendation. The technical implementation ideas of this technical solution include: 1. Use JavaScript to call the file management interface of Windows to complete the function of obtaining archives from the Windows side; 2. Use Cookies and BeautifulSoup4 technology to obtain the user's cloud archive download link, and download and transfer it through gost technology; 3. Use OSS technology to store the archives uploaded by users.

[0017] In addition, this application adds intelligent archive content parsing and feature recognition technology on the basis of the above technical solutions, which can specifically include the following technologies: Intelligent recognition technology for archive data structure; research on automatic analysis and intelligent structure parsing methods for unknown game archive formats; use deep learning methods to achieve automatic feature extraction and marking of unstructured archive data.

[0018] Based on technologies such as AI visual recognition and OCR, automatically recognize and structurally extract screenshots, progress screens, equipment, and character attribute data in the archive; based on the extracted data, accurately model the player's game progress and playing style.

[0019] Implement an intelligent archive difference analysis and comparison method to automatically judge the key differences between different players' archives (such as items, skills, plot progress); according to the difference analysis results, personalized recommend archive files with specific progress or specific functions for users.

[0020] The following describes the content of the technical solution of this application in detail in combination with the accompanying drawings and specific embodiments.

[0021] Figure 1 It is a schematic flowchart of a personalized recommendation method for single-player game archives based on intelligent archive parsing provided by an embodiment of this application. As Figure 1 shown, the personalized recommendation method for single-player game archives based on intelligent archive parsing can specifically include: S101, locate and read the archive file of the single-player game, transmit the archive file to the cloud storage through an encrypted link, and attach integrity verification information during the upload process; S102, when the cloud receives the archive file, perform archive format recognition and structured parsing operations on the archive file to obtain a structured data set; S103, extract text features based on the structured data set to generate text feature vectors; S104, collect the historical game behavior data of the target user to generate a user portrait vector corresponding to the target user; S105, for multiple candidate archives parsed by the cloud, based on the text feature vector and the user portrait vector, use a multi-dimensional difference metric model to calculate the difference degree value of each candidate archive relative to the target user; S106. Sort the candidate archives according to the difference degree value, generate an archive recommendation list, and send the archive recommendation list to the target user terminal.

[0022] In some embodiments, locate and read the save file of the single-player game, transmit the save file to the cloud storage via an encrypted link, and append integrity verification information during the upload process, including: Based on the preset save path mapping rule, call the operating system file management interface to traverse the local storage medium to automatically locate the save file corresponding to the target game identifier; When a write event of the save file is detected, read the changed data and generate a data packet to be uploaded according to a predetermined capture strategy.

[0023] Specifically, in this embodiment, the client process runs resident on the user device when Game A is started. To ensure that the game save can be quickly locked without manual intervention, the client pre-sets a mapping rule from the game identifier to the relative path of the save. The mapping rule is loaded into the key-value hash table in memory during the initialization phase; when the directory pointed to by the rule does not exist or is overridden by the user's custom settings, the client will call the operating system standard file management interface (FindFirstFileEx in Windows API, opendir / readdir in Linux) to recursively traverse the common subdirectories in the user's home directory. During the traversal process, the client not only checks whether the file extension is ".sav", but also synchronously reads the first 64 bytes of the header of each candidate file and performs a bitwise comparison with the save fingerprint whitelist. Only when the fingerprints are exactly the same, it is determined as the target save file and its current file length and the last modification time are recorded.

[0024] Further, after the location is completed, the client immediately registers a write callback with the kernel event subsystem to accurately capture all data when the save file is modified. On the Windows platform, the client subscribes to the FILE_WRITE_DATA event through ReadDirectoryChangesW; on the Linux platform, it listens to the IN_MODIFY event through inotify_add_watch. When the operating system triggers the callback, the client re-queries the file length. If an increase in length is detected, it sequentially reads the newly added bytes starting from the historical offset; if the length remains unchanged and the timestamp is updated, binary difference based on the Rabin fingerprint algorithm is performed to extract the overwritten block. The all-data capture strategy supports two-dimensional control of the time threshold and the size threshold: if the cumulative cache exceeds 256 kB or it has been more than 30 s since the last upload, a data packet is immediately generated, otherwise it is temporarily stored in the circular buffer to reduce the uplink jitter.

[0025] In some examples, the data packet encapsulation follows a fixed format. The client first writes the protocol identifier "GA-SAVE-UPLD", followed by an 8-byte file offset and a 4-byte fragment length, and then appends the actual full data. To ensure that it is not tampered with during transmission, the client calculates the SHA256 digest of the "protocol identifier + metadata + full data" as a whole, and generates a 32-byte integrity check value through HMAC-SHA256 in combination with the session key. This check value is appended to the end of the data packet. The entire data packet is then placed in the queue to be sent.

[0026] The encryption chain is established by TLS1.3. During the handshake, elliptic curve Diffie–Hellman is used to complete the key negotiation, and the subsequent data channel uses AES-256-GCM for symmetric encryption and decryption. The client pushes the encapsulated data packets in the form of HTTP / 2 data frames. The cloud gateway immediately decrypts and verifies the HMAC after receiving each frame; the full data that passes the verification is written to the object storage according to the offset. If the verification fails, it is discarded and an error code is returned to prompt the client to retransmit. The object storage manages files in a hierarchical directory of "game identifier - user ID - archive version", and at the same time writes the metadata written this time to the queue for subsequent parsing modules to consume.

[0027] To prevent data gaps caused by network interruptions, the client will synchronously update the local breakpoint file after each successful upload, recording the latest offset. When a link anomaly is detected and disconnected, it will automatically reconnect and continue sending from the breakpoint to ensure the logical continuity of the file content in the cloud. If the user uses the same account on multiple devices, the cloud resolves write conflicts through the write timestamp and version number policy.

[0028] By automatically locating and real-time monitoring the archive on the client side, adopting the data packet encapsulation method of full capture plus HMAC integrity check, and constructing a TLS1.3 encryption channel at the transport layer, this embodiment takes into account the transmission bandwidth, data consistency and security, realizes the efficient and reliable upload of single-player game archives, and lays a trusted data foundation for subsequent archive format parsing and personalized recommendation.

[0029] In some embodiments, archive format recognition and structured parsing operations are performed on the archive file to obtain a structured data set, including: Obtain the binary data stream of the archive file; Input the binary data stream into the archive format recognition module, and the archive format recognition module includes: The first recognition sub-module is used to match the preset format dictionary based on fingerprint features. If the match is successful, it outputs a predefined parsing template corresponding to the archive file; The second recognition sub-module is used to call the byte sequence analysis model based on deep learning to automatically generate the structure description of the archive file when the match is not successful; Based on a predefined parsing template or structure description, perform field parsing on the binary data stream to obtain an initial set of fields; Perform field type mapping, index marking, and redundancy elimination processing on the initial set of fields to generate a structured data set.

[0030] Specifically, in the following embodiments, taking the local save file of "Game A" as an object, the entire process of how to complete save format recognition, structure description generation, and field-level structured parsing in the cloud is elaborated in detail. This embodiment is jointly implemented relying on an object storage service, a serverless computing platform, and a deep learning inference service.

[0031] When the player's terminal completes an incremental save upload through encryption, the object storage generates an "object creation" event. The event triggers a serverless computing instance (function service). The function service calls the object storage interface to read the complete binary data of the save in a streaming manner, without landing on the local disk, and directly passes it to the next processing stage.

[0032] The save format recognition module consists of a first recognition sub-module (fingerprint matching) and a second recognition sub-module (deep analysis), and the two are executed in sequence.

[0033] In some examples, the first recognition sub-module: fingerprint matching, may include the following: Fingerprint database construction: The platform pre-collects the header flags, magic numbers, fixed offset check bytes, and typical length distributions of common single-player game saves to form fingerprint entries, which are stored in a high-performance key-value database.

[0034] Matching process: Read the first 4 KB bytes and several key offset bytes of the save; calculate the hash fingerprint and retrieve it in the database; if a matching entry is found, directly return the "predefined parsing template" associated with the fingerprint entry.

[0035] In some examples, the second recognition sub-module: deep learning byte sequence analysis, may include the following: When the fingerprint matching fails, enter the deep analysis process: Model structure: Adopt a pre-trained byte sequence Transformer encoder-decoder. The encoder focuses on the global byte distribution, and the decoder outputs a "field boundary marker sequence".

[0036] Inference steps: Slice the complete binary stream and use it as the model input; the model outputs the field number and the speculated type (integer, floating point, UTF-8 string, compressed block, etc.) to which each byte belongs; generate a machine-readable "structure description file", which internally presents the field name, start offset, length, data type, and nesting relationship in the form of JSON-Schema.

[0037] Further, if the first sub-module has output a predefined parsing template, the parsing engine extracts fields one by one according to the field order, data type, and byte width specified in the template, and parses multi-byte numerical values in little-endian or big-endian mode.

[0038] If a structure description file is used, the parsing engine reads the original stream sequentially according to the field boundaries inferred by the model and decodes it according to the inferred type rules; for string fields, UTF-8 is tried first, and if it fails, it falls back to the custom encoding table.

[0039] Further, if the field type is marked as "compressed block" or "nested structure", the parsing engine recursively calls itself. For the compressed block, it is first decompressed according to the inferred compression algorithm (such as LZ4, ZSTD) and then parsed; for the nested structure, the sub-structure is regarded as a new parsing unit to continue the field boundary recognition and decoding.

[0040] The platform maintains a "general field semantic library", which performs fuzzy matching on the parsed original fields (such as value_01, flag_07) with the semantic library and maps them to unified names (such as "role level", "task progress", "item list").

[0041] Fields for which the semantics cannot be determined are marked as "unknown fields" and accompanied by a confidence level for subsequent manual calibration or continuous training.

[0042] Further, a unique index key {game identifier} / {version number} / {field path} is generated for each field and written into the index database for subsequent query and difference calculation. For array or list fields, the number of elements and offset index are additionally recorded to enable random access.

[0043] Fingerprint comparison is used for the "snapshot segments" continuously written at different time points, and only the latest snapshot is retained; for the configuration segments that appear multiple times in the archive but have the same content, deduplication is performed through hash comparison to reduce the volume of the parsing results.

[0044] The field set after post-processing is encapsulated into a hierarchical JSON document, and at the same time, a binary Protocol-Buffer version is generated for efficient transmission.

[0045] The JSON document is written into the NoSQL document database with a multi-dimensional index of "user identifier - game identifier - archive version"; the Protocol-Buffer file is saved in the object storage and associated with the "binary backup path" recorded in the JSON document.

[0046] After the parsing result is successfully written, the "data available" event is triggered for real-time consumption by subsequent multi-modal feature fusion and difference calculation modules.

[0047] For example, in one example, after the save file of Game A is uploaded, it fails to match in the fingerprint database. The system automatically calls the deep learning analysis model and identifies 60 primary fields, including 3 compressed packets and 5 nested lists.

[0048] After decompressing the compressed packet and parsing it, a character attribute table, a level status table, and an item list are obtained. After semantic mapping of the fields, param_05 in the character attribute table is mapped to "character experience value" with a confidence of 0.92; item_17 in the item list is mapped to "rare weapon" with a confidence of 0.88.

[0049] In the redundancy elimination stage, it is found that the snapshot segment appears 4 times, and the content is the same 3 times. Only the latest one is retained to improve the parsing efficiency.

[0050] The size of the finally generated structured data document is about 18% of the original save file, and it contains high-semantic fields such as "character status", "level nodes", and "backpack items" in full, providing an accurate data source for the subsequent extraction of progress vectors and gameplay vectors.

[0051] Through the method of this embodiment above, the cloud platform can automatically identify, perform field-level parsing, and unify structuring on single-player game save files from different sources, different formats, and even unknown formats without manual reverse engineering, providing a reliable high-dimensional data foundation for the personalized save file recommendation algorithm and significantly reducing the cost of new game access.

[0052] In some embodiments, text feature extraction is performed based on the structured data set to generate text feature vectors, including: Determine at least one text field from the structured data set as the analysis object; Perform a preprocessing operation on the text field, input the preprocessed sub-word sequence into the text embedding sub-module, and map each sub-word to an embedding vector sequence using the word table corresponding to the target game corpus domain; Input the embedding vector sequence into the context encoding sub-module, and the context encoding sub-module outputs a field-level context representation based on the multi-layer self-attention mechanism; Perform an aggregation operation on the field-level context representation to generate a text feature vector corresponding to the save file.

[0053] Specifically, in this embodiment, after obtaining the structured data set for the save file of Game A, the cloud parsing service first traverses the schema description of the data set. During the traversal, the service filters potential text fields through a dual strategy of field type marking and content statistics: on the one hand, it determines whether the field declaration type is string, and on the other hand, it samples and detects the average length of the field and the proportion of non-ASCII characters. When these metrics simultaneously meet the threshold requirements, the field is added to the "candidate text field" set. Subsequently, the system determines the semantic-intensive fields such as plot dialogues, mission notes, and user-defined tags as the final analysis objects according to the priorities specified in the business configuration file, so as to ensure that the subsequent feature extraction focuses on the text segments most relevant to user preferences.

[0054] Furthermore, in order to weaken the interference caused by case sensitivity, special symbols, and different encoding formats, each piece of text to be processed will go through a unified preprocessing pipeline. This pipeline first performs Unicode NFKC normalization on the original character sequence, then removes control characters and zero-width spaces, and uses a regular expression customized based on game domain jargon to retain high-value substrings such as equipment names and skill abbreviations. The preprocessed text is fed into a subword tokenizer. The tokenizer uses a BPE model with a vocabulary size of 30,000, which is offline trained on a composite corpus containing the text of hundreds of single-player games. It can regard compound meaning segments such as "excalibur" and "hp potion" as stable subwords, thus avoiding semantic dilution caused by splitting. The subword sequence output by the tokenizer is encoded into a fixed-length ID sequence for subsequent embedding mapping.

[0055] In some examples, the text embedding sub-module is responsible for mapping the above ID sequence into a dense vector sequence. This sub-module loads a set of pre-trained 256-dimensional subword vectors and appends a special token [CLS] before the input sequence to carry global semantics. For the change in sequence length, the system injects relative position information through position encoding, enabling the model to distinguish the word order exchange between "damage boost" and "boost damage". For out-of-vocabulary subwords, the module uses a hash bucket mechanism to map them to a fixed vector interval, avoiding vector sparsity caused by frequently occurring unknown words.

[0056] The context encoding sub-module is implemented based on a six-layer Transformer encoder. Each layer contains multi-head self-attention, a feed-forward network, LayerNorm, and residual connections. To fully exploit long-distance dependencies, the number of attention heads is set to 8, and both the key dimension and the value dimension are 64. During the inference phase, the encoder shares weights for the same batch of archives to achieve high-throughput parallel processing. The field-level context representation output by the encoder is extracted at the last layer. The [CLS] vector at position 0 naturally aggregates the global semantics. However, to further highlight key information, this embodiment introduces a learnable query vector to perform attention pooling on the entire sequence. This query vector is jointly optimized with the recommendation model during offline training and can dynamically adjust the contribution of each sub-word to the final representation.

[0057] After the aggregation operation, the system obtains a 256-dimensional text feature vector. This vector is then written into the feature index through L2 normalization and stored together with other types of features (such as the level progress vector and the item distribution vector) of the same archive, providing a unified vectorized input for the difference metric model. To support subsequent online retrieval, this embodiment synchronously generates inverted keys during the writing phase. The key values are obtained by projecting the vector through locality-sensitive hashing, which can complete the rough screening of similar vectors in milliseconds.

[0058] By maintaining an end-to-end consistent corpus domain and vector space in the combined process of text field screening, sub-word level embedding, Transformer context encoding, and attention aggregation, this embodiment effectively improves the capture accuracy of the semantic features of the archive text. Compared with methods that only rely on keywords or TF-IDF, this vector can more accurately reflect deep information such as the task background, character status, and player choices, thus significantly improving the matching relevance and personalization effect in subsequent difference metric and archive recommendation processes.

[0059] In some embodiments, historical game behavior data of a target user is collected to generate a user portrait vector corresponding to the target user, including: Obtaining multi-source game behavior records corresponding to the target user from the local terminal and the associated game platform server; Performing time normalization processing and feature screening on the multi-source game behavior records to construct a behavior feature set; Inputting the behavior feature set into the portrait vectorization model, embedding and encoding various behavior features according to a preset weight strategy, and using a vector aggregation algorithm to generate a user portrait vector; Associating and storing the user portrait vector with the corresponding target user identification information for subsequent calls by the multi-dimensional difference metric model.

[0060] Specifically, the platform side first reads the player's local log files on the personal computer through the terminal synchronization component. These log files are generated by the launcher and runtime monitoring module of Game A, and the content covers items such as daily playtime, the number of the most recently loaded levels, frequently used character classes, and the number of clicks on items in the quick bar. After parsing the logs, the synchronization component temporarily stores the key fields in the buffer.

[0061] Meanwhile, the platform backend polls and pulls the achievement unlocking list, friend online history, and paid item purchase list recorded by the same player in the cloud through the authorized game platform open interface, and aligns the primary keys of these cloud records with the log entries in the local buffer, using the player identifier, date-time stamp, and game process number as the association keys to form a merged entry of multi-source behavior records.

[0062] Before the merged behavior records enter the vectorization process, they need to undergo time normalization. The platform uses the unified Coordinated Universal Time (UTC) to map the local timestamps of records from different sources; for the overlapping parts of the international date line caused by different time zones, the interval window algorithm is used to eliminate the double-counted playtime.

[0063] Subsequently, the system performs feature screening on the behavior fields according to the preset correlation rules: the fields directly reflecting the degree of game investment (such as the cumulative weekly playtime) are marked with high weights; the fields closely related to gameplay preferences (such as the release frequency of melee skills) are retained; while the fields with a lower correlation with subsequent recommendations (such as the number of times the window is minimized) are excluded. After screening, a set of behavior features containing about twenty-odd indicators is formed, and each item contains a numerical value or category representation with a unified dimension.

[0064] Furthermore, the platform loads the user portrait vectorization model in the model inference service and uses the above set of behavior features as the input. For numerical features, the model directly maps them to a continuous vector space after interval normalization; for categorical features, the model references the pre-trained embedding matrix to convert the discrete labels into dense vectors with a fixed dimension.

[0065] Subsequently, the system uses a gated fusion network to perform weighted superposition on each dimension of the embedding according to the category weights set in the policy file, and generates a user portrait vector with a length of 128 dimensions through a vector aggregation algorithm (including average pooling and principal component dimensionality reduction). Logically, this vector is divided into two segments: the first half mainly represents the overall activity and progress tendency of the player, and the second half presents the preference weights of the player for various gameplay elements such as combat, exploration, and collection.

[0066] The generated user profile vector is written into the vector database together with the unique identifier of the target player. This database supports dual indexing by "player identifier - latest generation time" and retains the first three historical versions for backtracking. After the vector entry is successfully inserted, the system immediately triggers a callback to push the storage address of the new vector to the difference metric service for it to call during the next round of archived recommendation calculation.

[0067] Through the above continuous and closed-loop processing flow, this embodiment realizes the unified aggregation of multi-source historical behaviors of players, the embedded encoding with weight control, and the efficient and persistent storage, providing reliable and real-time updated user profile data for subsequent personalized archived recommendations based on difference degrees.

[0068] In some embodiments, based on the text feature vector and the user profile vector, a multi-dimensional difference metric model is used to calculate the difference degree value of each candidate archive relative to the target user, including: Obtain the progress vector and gameplay vector corresponding to each candidate archive; In the multi-dimensional difference metric model, calculate the progress difference component between the progress vectors and the gameplay difference component between the gameplay vectors respectively according to the preset distance function; According to the weight configuration strategy, weight and fuse the progress difference component and the gameplay difference component to obtain the total difference degree value corresponding to the candidate archive; Associate and cache the total difference degree value with the candidate archive identifier for subsequent sorting to generate an archived recommendation list.

[0069] Specifically, in a recommendation calculation for players of "Game A", the cloud scheduling service first sends a retrieval instruction to the vector database to batch pull 200 candidate archive entries newly uploaded in the past 72 hours. For each archive, the system synchronously obtains two sets of numerical vectors: one is a 256-dimensional progress vector used to describe the level progress and task completion degree, and the other is a 128-dimensional gameplay vector used to reflect the combat style and exploration preference.

[0070] At the same time, the scheduling service loads the progress vector and gameplay vector corresponding to the target player in the same memory context. To ensure the comparability of each group of data, the platform has performed L2 normalization on all dimensions during the vector extraction stage, so there is no need to process again here.

[0071] Further, the difference measurement phase is completed in parallel on the GPU nodes by a dedicated multi-dimensional vector calculation module. For the progress dimension, the system uses the Euclidean distance as the preset distance function: the module compares the progress vectors of the candidate archives, calculates the differences element by element, sums the squares and takes the square root to obtain the progress difference component; if there are missing values in some key chapter dimensions, the system uses a missing penalty coefficient inversely proportional to the chapter weight to amplify the differences to prevent the underestimation of the progress difference caused by data holes. For the gameplay dimension, the platform uses "one minus cosine similarity" as the distance function: the module first calculates the cosine similarity between the gameplay vector of the candidate archive and the user portrait vector, and then obtains the gameplay difference component where the larger the value, the more significant the difference, by subtracting this value from one.

[0072] Further, after the independent calculation of the two types of components, the weight fusion module performs weighted processing according to the policy file issued by the configuration center. By default, the progress difference component is given a weight of sixty percent, and the gameplay difference component is given a weight of forty percent; if the target player shows the "adventure exploration" label in their portrait, the policy file will increase the gameplay weight to fifty percent to reflect the player's sensitivity to the gameplay style matching degree.

[0073] The module calculates the total difference degree value of each candidate archive relative to the target player in a weighted average manner, and packages this value together with the archive unique identifier into a key-value pair and writes it into the high-performance memory cache. The key adopts the format of "session ID - candidate archive ID", and the value includes the progress difference component, the gameplay difference component, and the total difference degree; the cache is set with a validity period of thirty minutes to support multiple rounds of iteration and fast re-ranking of the current recommendation session.

[0074] Subsequently, the sorting service pulls all the cache entries at once, sorts them in ascending order according to the total difference degree, and returns the top twenty archives with the lowest difference degree as the list to be pushed to the client; at the same time, visualizes the split results of the progress difference and the gameplay difference as a radar chart, enabling players to intuitively understand the distance between each recommended archive and their own state.

[0075] Through the continuous processing flow of the above embodiments, the platform realizes batch vector retrieval of candidate archives, dual-channel difference calculation, weight adaptive fusion, and low-latency cache write-back, thereby generating a personalized and interpretable archive recommendation list for players of Game A within milliseconds.

[0076] In some embodiments, after the archive recommendation list is sent to the target user terminal, the method further includes: When the target user terminal receives the archive recommendation list, it obtains the incremental differential package of the corresponding candidate archive according to the user instruction; After backing up the original archive of the target user, inject the incremental differential package into the local archive directory of the target user; After the injection is completed, perform an archive integrity check. If the check fails, restore to the original archive.

[0077] Specifically, for example, in the actual application scenario of player A of game A, after the cloud recommendation service completes the sorting of candidate archives, it pushes an archive recommendation list containing twenty entries to the player's terminal in the form of a JSON payload. In addition to the archive identifier, each entry also carries the baseline version number of the archive relative to the player's current version, the download address of the incremental differential package, the size of the differential package, the target verification hash, and the RSA-2048 digital signature. The client first caches the list locally and displays it to the player; when the player actively clicks on one of the recommendations, the client requests the corresponding incremental differential package from the content delivery network. To ensure the integrity of the data during transmission, the link between the client and the CDN enables TLS 1.3. After the download is completed, the digital signature is verified immediately. If the signature verification fails, the process is terminated and the user is prompted.

[0078] Before officially injecting the differential package, the client uses the file handle locking mechanism to ensure that game A is not currently running, then copies the player's existing original archive file to the "backup" subfolder in the same archive directory, and attaches a timestamp and a random number to the file name to avoid overwriting the old backup. After the copying is completed, the SHA-256 value of the original file is calculated again and written to the local log for subsequent rollback verification.

[0079] The differential package file uses the BSDiff format and is generated offline by the cloud with the player's existing archive as the "old version" and the candidate archive as the "new version" when generating the recommendation list. Therefore, the client only needs to call the differential merge engine locally to perform a patching operation on the original archive. During the merging process, the differential engine first decompresses the differential package and checks the baseline version number against the version number recorded in the local original archive; if the two are inconsistent, the injection is automatically abandoned and the backup is restored. After passing the check, the differential engine applies the patch in byte block order, generates a new target archive file, and writes it back to the original archive path.

[0080] After writing back, the client immediately calculates the SHA-256 of the new file and compares it with the target hash attached to the differential package. If the hash values are the same, it means the injection is successful. The client deletes the previously created backup file and prompts "Synchronization successful" on the interface; if the hashes are inconsistent or an I / O exception occurs during the file writing process, the client immediately replaces the new file with the backup file, refreshes the disk cache, and calculates the hash again to confirm that it has been restored to the state before injection. At the same time, the error code and log are uploaded to the cloud fault analysis service.

[0081] During the entire process, the client has set timeout and retry policies for key steps: immediately abort if the digital signature verification fails; if the differential merge fails after three retries, abandon the patch and retain the backup; if the hash verification fails, trigger a single rollback. If the rollback is successful, record "restored". If the rollback also fails, enter the secure lock state and prompt the user for manual intervention. Through the above backup, injection, verification, and rollback mechanisms, it is ensured that the player's save file can seamlessly obtain the new progress during the personalized synchronization process and will not cause the loss or damage of the original data due to abnormal operations.

[0082] The following is an embodiment of the apparatus of the present application, which can be used to execute the method embodiment of the present application. For details not disclosed in the apparatus embodiment of the present application, please refer to the method embodiment of the present application.

[0083] Figure 2 It is a schematic structural diagram of a personalized recommendation device for single-player game save files based on intelligent save file parsing provided by an embodiment of the present application. As Figure 2 shown, the personalized recommendation device for single-player game save files based on intelligent save file parsing includes: A transmission module 201, configured to locate and read the save file of a single-player game, transmit the save file to cloud storage via an encrypted link, and append integrity verification information during the upload process; An analysis module 202, configured to perform save file format recognition and structured analysis operations on the save file when the cloud receives the save file, to obtain a structured data set; An extraction module 203, configured to extract text features based on the structured data set to generate a text feature vector; A generation module 204, configured to collect historical game behavior data of a target user to generate a user portrait vector corresponding to the target user; A calculation module 205, configured to calculate the difference degree value of each candidate save relative to the target user based on the text feature vector and the user portrait vector by using a multi-dimensional difference metric model for multiple candidate saves that have been parsed by the cloud; A sorting module 206, configured to sort the candidate saves according to the difference degree value to generate a save recommendation list, and send the save recommendation list to the target user terminal.

[0084] In some embodiments, Figure 2 the transmission module 201 of traverses the local storage medium by calling the operating system file management interface based on a preset save path mapping rule to automatically locate the save file corresponding to the target game identifier; when a write event of the save file is detected, read the changed data, and generate a data packet to be uploaded according to a predetermined capture policy.

[0085] In some embodiments, Figure 2The parsing module 202 obtains the binary data stream of the archived file; inputs the binary data stream into the archived format recognition module, which includes: a first recognition sub-module for matching the preset format dictionary based on fingerprint features and outputting a predefined parsing template corresponding to the archived file if the match is successful; a second recognition sub-module for calling a byte sequence analysis model based on deep learning to automatically generate a structure description of the archived file when the match is not successful; parsing the binary data stream based on the predefined parsing template or structure description to obtain an initial field set; performing field type mapping, index marking, and redundancy elimination processing on the initial field set to generate a structured data set.

[0086] In some embodiments, Figure 2 The extraction module 203 determines at least one text field from the structured data set as the analysis object; performs a preprocessing operation on the text field, inputs the preprocessed sub-word sequence into the text embedding sub-module, and maps each sub-word to an embedding vector sequence using a vocabulary corresponding to the target game corpus domain; inputs the embedding vector sequence into the context encoding sub-module, and the context encoding sub-module outputs a field-level context representation based on a multi-layer self-attention mechanism; performs an aggregation operation on the field-level context representation to generate a text feature vector corresponding to the archived file.

[0087] In some embodiments, Figure 2 The generation module 204 obtains multi-source game behavior records corresponding to the target user from the local terminal and the associated game platform server; performs time normalization processing and feature screening on the multi-source game behavior records to construct a behavior feature set; inputs the behavior feature set into the portrait vectorization model, performs embedding encoding on various behavior features according to a preset weight strategy, and uses a vector aggregation algorithm to generate a user portrait vector; associates and stores the user portrait vector with the corresponding target user identification information for subsequent calls by the multi-dimensional difference metric model.

[0088] In some embodiments, Figure 2 The calculation module 205 obtains the progress vector and the gameplay vector corresponding to each candidate archive; in the multi-dimensional difference metric model, calculates the progress difference component between the progress vectors and the gameplay difference component between the gameplay vectors respectively according to a preset distance function; performs weighted fusion on the progress difference component and the gameplay difference component according to a weight configuration strategy to obtain the total difference degree value corresponding to the candidate archive; associates and caches the total difference degree value with the candidate archive identifier for subsequent sorting to generate an archive recommendation list.

[0089] In some embodiments, Figure 2After the verification module 207 sends the archived recommendation list to the target user terminal, when the target user terminal receives the archived recommendation list, it obtains the incremental differential package of the corresponding candidate archive according to the user instruction; after backing up the original archive of the target user, it injects the incremental differential package into the local archive directory of the target user; after the injection is completed, it performs an archive integrity check, and if the check fails, it restores to the original archive.

[0090] It should be understood that the order of the numbers of the steps in the above embodiments does not mean the order of execution. The order of execution of each process should be determined by its function and internal logic, and should not constitute any limitation to the implementation process of the embodiments of the present application.

[0091] Figure 3 is a schematic structural diagram of the electronic device 3 provided by the embodiment of the present application. As Figure 3 shown, the electronic device 3 of this embodiment includes: a processor 301, a memory 302, and a computer program 303 stored in the memory 302 and executable on the processor 301. When the processor 301 executes the computer program 303, it implements the steps in the above various method embodiments. Alternatively, when the processor 301 executes the computer program 303, it implements the functions of each module / unit in the above various device embodiments.

[0092] Exemplarily, the computer program 303 can be divided into one or more modules / units. The one or more modules / units are stored in the memory 302 and executed by the processor 301 to complete the present application. The one or more modules / units can be a series of computer program instruction segments capable of performing specific functions, and the instruction segments are used to describe the execution process of the computer program 303 in the electronic device 3.

[0093] The electronic device 3 can be a desktop computer, a notebook, a palm computer, a cloud server and other electronic devices. The electronic device 3 can include, but is not limited to, the processor 301 and the memory 302. Those skilled in the art can understand that Figure 3 merely an example of the electronic device 3 does not constitute a limitation to the electronic device 3, and may include more or fewer components than shown in the figure, or combine some components, or different components. For example, the electronic device may further include input / output devices, network access devices, buses, etc.

[0094] The processor 301 may be a central processing unit (CPU), or 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. The general-purpose processor may be a microprocessor or any conventional processor, etc.

[0095] The memory 302 may be an internal storage unit of the electronic device 3. For example, the hard disk or memory of the electronic device 3. The memory 302 may also be an external storage device of the electronic device 3. For example, a plug-in hard disk, a smart media card (SMC), a secure digital (SD) card, a flash card, etc. equipped on the electronic device 3. Further, the memory 302 may also include both the internal storage unit and the external storage device of the electronic device 3. The memory 302 is used to store computer programs and other programs and data required by the electronic device. The memory 302 may also be used to temporarily store data that has been output or is to be output.

[0096] Those skilled in the art can clearly understand that, for the convenience and simplicity of description, only the above-mentioned division of each functional unit and module is used as an example. In actual applications, the above-mentioned functions can be allocated to different functional units and modules according to needs, that is, the internal structure of the device is divided into different functional units or modules to complete all or part of the functions described above. Each functional unit and module in the embodiment can be integrated into a processing unit, or each unit can exist physically alone, or two or more units can be integrated into one unit. The above-mentioned integrated unit can be implemented in the form of hardware or in the form of a software functional unit. In addition, the specific names of each functional unit and module are only for the convenience of mutual distinction and do not limit the protection scope of the present application. The specific working processes of the units and modules in the above system can refer to the corresponding processes in the foregoing method embodiments and will not be elaborated herein.

[0097] In the above embodiments, the descriptions of the respective embodiments have their own emphases. For the parts not detailed or recorded in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0098] Those of ordinary skill in the art can realize that the units and algorithm steps of each example described in combination with the embodiments disclosed herein can be implemented by electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are executed in a hardware or software manner depends on the specific application and design constraints of the technical solution. Professional technicians can use different methods for each specific application to implement the described functions, but such implementation should not be considered to exceed the scope of this application.

[0099] In the embodiments provided in this application, it should be understood that the disclosed device / computer device and method can be implemented in other ways. For example, the device / computer device embodiments described above are merely illustrative. For example, the division of modules or units is only a logical function division. In actual implementation, there may be other division methods. Multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. In addition, the displayed or discussed mutual coupling or direct coupling or communication connection can be through some interfaces. The indirect coupling or communication connection of the device or unit can be in an electrical, mechanical or other form.

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

[0101] In addition, the functional units in each embodiment of this application can be integrated into one processing unit, or each unit can exist physically alone, or two or more units can be integrated into one unit. The above integrated units can be implemented in the form of hardware or in the form of software functional units.

[0102] If the integrated module / unit is implemented in the form of 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, to implement all or part of the processes in the above-described embodiment methods of this application, it can also be completed by instructing relevant hardware through a computer program. The computer program can be stored in a computer-readable storage medium. When the computer program is executed by a processor, the steps of the above-described various method embodiments can be implemented. The computer program can include computer program code, and the computer program code can be in the form of source code, object code, executable file, or some intermediate form, etc. The computer-readable medium can include: any entity or device capable of carrying computer program code, recording medium, USB flash drive, mobile hard disk, magnetic disk, optical disc, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signal, telecommunication signal, and software distribution medium, etc.

[0103] The above embodiments are only used to illustrate the technical solutions of this application, rather than to limit them; although the technical solutions of this application have been described in detail with reference to the foregoing embodiments, those of ordinary skill in the art should understand that: they can still modify the technical solutions recorded in the foregoing embodiments, or perform equivalent replacements on some of the technical features; and these modifications or replacements do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the various embodiments of this application, and should all be included within the protection scope of this application.

Claims

1. A personalized recommendation method for single-player game saves based on intelligent archive parsing, characterized in that, Including: Locate and read the save file of a single-player game, transmit the save file to cloud storage via an encrypted link, and append integrity verification information during the upload process; When the cloud receives the save file, perform save format recognition and structured parsing operations on the save file to obtain a structured data set; Extract text features based on the structured data set to generate text feature vectors; Collect the historical game behavior data of the target user to generate a user portrait vector corresponding to the target user; For multiple candidate saves parsed by the cloud, based on the text feature vectors and user portrait vectors, use a multi-dimensional difference metric model to calculate the difference degree values of each candidate save relative to the target user; Sort the candidate saves according to the difference degree values to generate a save recommendation list, and send the save recommendation list to the target user terminal.

2. The method according to claim 1, characterized in that, The locating and reading the save file of a single-player game, transmitting the save file to cloud storage via an encrypted link, and appending integrity verification information during the upload process includes: Based on a preset save path mapping rule, call the operating system file management interface to traverse the local storage medium to automatically locate the save file corresponding to the target game identifier; When a write event of the save file is detected, read the changed data and generate a data packet to be uploaded according to a predetermined capture strategy.

3. The method according to claim 1, wherein The performing save format recognition and structured parsing operations on the save file to obtain a structured data set includes: Obtain the binary data stream of the save file; Input the binary data stream into a save format recognition module, and the save format recognition module includes: A first recognition sub-module for matching a preset format dictionary based on fingerprint features, and if the match is successful, output a predefined parsing template corresponding to the save file; A second recognition sub-module for calling a byte sequence analysis model based on deep learning to automatically generate a structure description of the save file when the match is not successful; Based on the predefined parsing template or the structure description, perform field parsing on the binary data stream to obtain an initial field set; Perform field type mapping, index marking, and redundancy elimination processing on the initial field set to generate a structured data set.

4. The method according to claim 1, characterized in that, The extracting text features based on the structured data set to generate text feature vectors includes: Determine at least one text field from the structured data set as the analysis object; Perform preprocessing operations on the text field, input the preprocessed sub-word sequence into a text embedding sub-module, and map each sub-word to an embedding vector sequence using a word table corresponding to the target game corpus domain; Input the embedding vector sequence into a context encoding sub-module, and the context encoding sub-module outputs a field-level context representation based on a multi-layer self-attention mechanism; Perform an aggregation operation on the field-level context representation to generate a text feature vector corresponding to the save file.

5. The method according to claim 1, characterized in that, The collecting the historical game behavior data of the target user to generate a user portrait vector corresponding to the target user includes: Obtain multi-source game behavior records corresponding to the target user from the local terminal and the associated game platform server; Perform time normalization processing and feature screening on the multi-source game behavior records to construct a set of behavior features; Input the set of behavior features into the portrait vectorization model, perform embedding encoding on various behavior features according to the preset weight strategy, and use the vector aggregation algorithm to generate the user portrait vector; Associate and store the user portrait vector with the corresponding target user identification information for subsequent calls by the multi-dimensional difference measurement model.

6. The method according to claim 4, wherein Based on the text feature vector and the user portrait vector, use the multi-dimensional difference measurement model to calculate the difference degree values of each candidate archive relative to the target user, including: Obtain the progress vector and gameplay vector corresponding to each candidate archive; In the multi-dimensional difference measurement model, calculate the progress difference component between the progress vectors and the gameplay difference component between the gameplay vectors respectively according to the preset distance function; According to the weight configuration strategy, perform weighted fusion on the progress difference component and the gameplay difference component to obtain the total difference degree value corresponding to the candidate archive; Associate and cache the total difference degree value with the candidate archive identifier for subsequent sorting to generate an archive recommendation list.

7. The method according to claim 1, wherein After the archive recommendation list is sent to the target user terminal, the method further includes: When the target user terminal receives the archive recommendation list, obtain the incremental differential package of the corresponding candidate archive according to the user instruction; After backing up the original archive of the target user, inject the incremental differential package into the local archive directory of the target user; Perform archive integrity verification after the injection is completed. If the verification fails, restore to the original archive.

8. A single-player game save personalized recommendation device based on intelligent archive parsing, characterized in that, Include: A transmission module for locating and reading the archive file of the single-player game, transmitting the archive file to the cloud storage via an encrypted link, and attaching integrity verification information during the upload process; A parsing module for performing archive format recognition and structured parsing operations on the archive file when the cloud receives the archive file to obtain a structured data set; An extraction module for performing text feature extraction based on the structured data set to generate a text feature vector; A generation module for collecting the historical game behavior data of the target user and generating a user portrait vector corresponding to the target user; A calculation module for calculating the difference degree values of each candidate archive relative to the target user based on the text feature vector and the user portrait vector by using the multi-dimensional difference measurement model for the multiple candidate archives parsed by the cloud; A sorting module for sorting the candidate archives according to the difference degree values to generate an archive recommendation list and sending the archive recommendation list to the target user terminal.

9. An electronic device, comprising a memory, a processor, and a computer program stored on the memory and executable on the processor, characterized in that, The processor implements the steps of the method according to any one of claims 1 to 7 when executing the computer program.

10. A computer-readable storage medium storing a computer program, characterized in that, The computer program implements the steps of the method according to any one of claims 1 to 7 when executed by the processor.

Images