Method and device for personalized recommendation of single-player game archives based on intelligent archive analysis

Abstract

The present application provides a method and device for personalized recommendation of stand-alone game archives based on intelligent archive parsing. The method includes: locating and reading the archive files of the stand-alone game, performing archive format recognition and structured parsing operations on the archive files; extracting text features based on the structured data set to generate a text feature vector; using a multi-dimensional difference measurement model to calculate the difference value of each candidate archive relative to the target user based on the text feature vector and the user portrait vector; sorting the candidate archives according to the difference value, generating an archive recommendation list, and sending the archive recommendation list to the target user terminal. The present application can achieve unified parsing of heterogeneous archives, obtain standardized progress and gameplay vectors, and user portrait matching driven by difference metrics, realize personalized archive recommendations, and improve the security and reliability of cross-end synchronization.

Description

Technical Field

[0001] The present application relates to the field of data processing technology, and in particular to a method and device for recommending personalized archives for stand-alone games based on intelligent archive analysis. Background Art

[0002] The progress of single-player games is usually saved in local save files. When players change devices, reinstall the system, or try out someone else's progress, they need to upload the save files to the cloud and synchronize them across different devices. Existing solutions mainly fall into the following two categories:

[0003] Built-in cloud archive services: The platform provides basic backup functionality, with archives uploaded and downloaded solely through byte-by-byte comparison. Third-party archive sharing communities: Some forums or cloud storage platforms distribute archives as attachments, which players manually download and overwrite local files.

[0004] However, the above prior art still has the following defects:

[0005] First, heterogeneous formats are difficult to parse, and the archive structures of various games vary greatly. Existing services only perform file-level copying and cannot identify the level, character, or item information contained in the archive.

[0006] Next, due to the lack of differentiated recommendation capabilities, players can only filter archives by title or upload time, and cannot obtain precisely matched archive files based on their own game progress and gameplay preferences.

[0007] Then, the integrity and security are insufficient, files are easily tampered with or damaged during sharing, and there is a lack of a unified hash verification and rollback mechanism.

[0008] Finally, there is a lack of automatic management of consistency across devices. Existing solutions mostly rely on manual overwriting of archives. If an operational error occurs, progress can be lost and version consistency cannot be maintained across multiple terminals. Summary of the Invention

[0009] In view of this, the embodiments of the present application provide a method and device for personalized recommendation of stand-alone game archives based on intelligent archive parsing to solve the problems of existing heterogeneous archives being difficult to automatically parse, unable to obtain unified progress and gameplay features, lacking a precise matching mechanism based on player portraits, difficulty in recommending suitable archives, lacking encryption and integrity verification, and low cross-end synchronization security.

[0010] In a first aspect of an embodiment of the present application, a method for personalized recommendation of stand-alone game archives based on intelligent archive parsing is provided, comprising: locating and reading the archive files of the stand-alone game, transmitting the archive files to cloud storage via an encrypted link, and attaching integrity verification information during the upload process; when the cloud receives the archive files, performing archive format recognition and structured parsing operations on the archive files to obtain a structured data set; performing text feature extraction based on the structured data set to generate a text feature vector; collecting historical game behavior data of the target user to generate a user portrait vector corresponding to the target user; for multiple candidate archives parsed on the cloud, based on the text feature vector and the user portrait vector, using a multidimensional difference measurement model to calculate the difference value of each candidate archive relative to the target user; sorting the candidate archives according to the difference value, generating an archive recommendation list, and sending the archive recommendation list to the target user terminal.

[0011] According to a second aspect of an embodiment of the present application, a personalized recommendation device for stand-alone game archives based on intelligent archive parsing is provided, comprising: a transmission module for locating and reading the archive files of the stand-alone game, transmitting the archive files to 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 files after the cloud receives the archive files, so as 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 historical game behavior data of the target user to generate a user portrait vector corresponding to the target user; a calculation module for calculating the difference value of each candidate archive relative to the target user based on the text feature vector and the user portrait vector for multiple candidate archives parsed on the cloud using a multidimensional difference measurement model; a sorting module for sorting the candidate archives according to the difference value, generating an archive recommendation list, and sending the archive recommendation list to the target user terminal.

[0012] According to a third aspect of an embodiment of the present application, an electronic device is provided, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the steps of the above method are implemented when the processor executes the computer program.

[0013] According to a fourth aspect of the embodiments of the present application, a computer-readable storage medium is provided, which stores a computer program. When the computer program is executed by a processor, the steps of the above method are implemented.

[0014] At least one of the above technical solutions adopted in the embodiments of the present application can achieve the following beneficial effects:

[0015] By locating and reading the archive files of stand-alone games, the archive files are transmitted to cloud storage via an encrypted link, and integrity verification information is attached during the upload process; when the cloud receives the archive files, archive format recognition and structured parsing operations are performed on the archive files to obtain a structured data set; text feature extraction is performed based on the structured data set to generate a text feature vector; historical game behavior data of the target user is collected to generate a user portrait vector corresponding to the target user; for multiple candidate archives that have been parsed on the cloud, based on the text feature vector and the user portrait vector, a multi-dimensional difference measurement model is used to calculate the difference value of each candidate archive relative to the target user; the candidate archives are sorted according to the difference value, an archive recommendation list is generated, and the archive recommendation list is sent to the target user terminal. This application can achieve unified parsing of heterogeneous archives, obtain standardized progress and gameplay vectors, user portrait matching driven by difference measurement, realize personalized archive recommendations, and improve the security and reliability of cross-end synchronization. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following briefly introduces the drawings required for use in the embodiments or descriptions of the prior art. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0017] Figure 1 This is a flowchart of a method for personalized recommendation of single-player game archives based on intelligent archive analysis provided by an embodiment of the present application;

[0018] Figure 2 This is a schematic diagram of the structure of a stand-alone game archive personalized recommendation device based on intelligent archive analysis provided by an embodiment of the present application;

[0019] Figure 3 It is a structural diagram of an electronic device provided in an embodiment of the present application. DETAILED DESCRIPTION

[0020] In the following description, specific details such as specific system structures and techniques are provided for purposes of illustration rather than limitation to facilitate a thorough understanding of the embodiments of the present application. However, it will be apparent to those skilled in the art that the present application may 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 obscuring the description of the present application with unnecessary detail.

[0021] In order to solve the problem of cloud archive synchronization function / synchronizing your own or using others in stand-alone games, this application provides a technical solution of archive distribution technology based on personalized recommendation - archive parsing. The technical implementation ideas of this technical solution include:

[0022] 1. Use js to call the Windows file management interface to complete the function of obtaining archives from the Windows side;

[0023] 2. Use Cookies and beautiful4 technology to obtain the user's cloud archive download link, and download and transfer it through gost technology;

[0024] 3. Use OSS technology to store archives uploaded by users.

[0025] In addition, this application adds intelligent archive content analysis and feature recognition technology on the basis of the above technical solutions, which may specifically include the following technologies:

[0026] 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 labeling of unstructured archive data.

[0027] Based on AI visual recognition, OCR and other technologies, it automatically identifies and extracts structured data from screenshots, progress screens, equipment, and character attributes in archives; based on the extracted data, it achieves accurate modeling of the player's game progress and play style.

[0028] Implement intelligent archive difference analysis and comparison methods to automatically determine the key differences between different players' archives (such as props, skills, and plot progress); based on the difference analysis results, provide users with personalized recommendations for archive files with specific progress or specific functions.

[0029] The contents of the technical solution of this application are described in detail below with reference to the accompanying drawings and specific embodiments.

[0030] Figure 1 This is a flow chart of a method for personalized recommendation of single-player game archives based on intelligent archive analysis provided by an embodiment of the present application. Figure 1 As shown, the method for personalized recommendation of single-player game archives based on intelligent archive analysis may specifically include:

[0031] S101, locate and read the archive file of the stand-alone game, transfer the archive file to cloud storage via an encrypted link, and attach integrity verification information during the upload process;

[0032] S102, after the cloud receives the archive file, it performs archive format recognition and structured parsing operations on the archive file to obtain a structured data set;

[0033] S103, extracting text features based on the structured data set to generate a text feature vector;

[0034] S104, collecting historical gaming behavior data of the target user and generating a user portrait vector corresponding to the target user;

[0035] S105, for the multiple candidate archives parsed in the cloud, using a multi-dimensional difference measurement model to calculate the difference value of each candidate archive relative to the target user based on the text feature vector and the user portrait vector;

[0036] S106 , sorting the candidate archives according to the difference values, generating an archive recommendation list, and sending the archive recommendation list to the target user terminal.

[0037] In some embodiments, locating and reading the archive file of a stand-alone game, transmitting the archive file to cloud storage via an encrypted link, and appending integrity verification information during the upload process include:

[0038] Based on the preset archive path mapping rules, the operating system file management interface is called to traverse the local storage medium to automatically locate the archive file corresponding to the target game identifier;

[0039] When a write event is detected for an archive file, the changed data is read and a data packet to be uploaded is generated according to a predetermined capture strategy.

[0040] Specifically, in this embodiment, the client process runs resident on the user's device upon the launch of Game A. To ensure that game saves can be quickly locked without manual intervention, the client presets a mapping rule from the game identifier to the relative path of the save. The mapping rule is loaded into a key-value hash table in memory during the initialization phase. When the directory pointed to by the rule does not exist or is overwritten by user-defined settings, the client calls the operating system's standard file management interface (using FindFirstFileEx in the Windows API and opendir / readdir in Linux) to recursively traverse common subdirectories in the user's home directory. During this traversal, the client not only checks whether the file extension is ".sav" but also synchronously reads the first 64 bytes of each candidate file header and compares them bit by bit against the save fingerprint whitelist. Only when the fingerprint is completely consistent is it identified as the target save file and its current file length and last modification time are recorded.

[0041] Furthermore, once positioning is complete, the client immediately registers a write callback with the kernel event subsystem to accurately capture the full data when the archived file is modified. On Windows platforms, the client subscribes to the FILE_WRITE_DATA event via ReadDirectoryChangesW; on Linux platforms, it listens for the IN_MODIFY event via inotify_add_watch. When the operating system triggers the callback, the client requeries the file length. If an increase in length is detected, the client sequentially reads the newly added bytes starting from the historical offset. If the length remains unchanged but the timestamp is updated, a binary difference based on the Rabin fingerprint algorithm is performed to extract the overwritten block. The full capture strategy supports dual-dimensional control of time thresholds and size thresholds: if the cumulative cache size exceeds 256kB or more than 30 seconds have passed since the last upload, a data packet is generated immediately; otherwise, it is temporarily stored in a ring buffer to reduce uplink jitter.

[0042] In some examples, 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 segment length, and then appends the actual full data. To ensure that the data is not tampered with during transmission, the client calculates the SHA256 digest of the "protocol identifier + metadata + full data" as a whole, and combines it with the session key using HMAC-SHA256 to generate a 32-byte integrity check value. This check value is appended to the end of the packet. The entire packet is then placed in the outgoing queue.

[0043] The encrypted link is established using TLS 1.3, with key negotiation performed using Elliptic Curve Diffie–Hellman during the handshake. Subsequent data channels utilize AES-256-GCM for symmetric encryption and decryption. The client pushes encapsulated data packets in HTTP / 2 data frames. The cloud gateway decrypts and verifies the HMAC upon receipt of each frame. Full data that passes verification is written to object storage at the specified offset. If verification fails, the data is discarded and an error code is returned, prompting the client to retransmit. Object storage manages files in a hierarchical directory structured as "game ID - user ID - archived version." The metadata written to this file is queued for subsequent consumption by the parsing module.

[0044] To prevent data gaps caused by network interruptions, the client automatically updates the local breakpoint file after each successful upload, recording the latest offset. If a link disconnect is detected, it automatically reconnects and continues sending from the breakpoint, ensuring logical continuity of cloud file content. If a user uses the same account on multiple devices, the cloud resolves write conflicts using a write timestamp and version number strategy.

[0045] By automatically locating and monitoring archives in real time on the client side, adopting a data packet encapsulation method with full capture and HMAC integrity verification, and building a TLS1.3 encrypted channel at the transport layer, this embodiment takes into account transmission bandwidth, data consistency and security, and achieves efficient and reliable uploading of stand-alone game archives, laying a reliable data foundation for subsequent archive format analysis and personalized recommendations.

[0046] In some embodiments, performing archive format recognition and structured parsing operations on the archive file to obtain a structured data set includes:

[0047] Get the binary data stream of the archive file;

[0048] The binary data stream is input into the archive format recognition module, which includes:

[0049] A first identification submodule is configured to match a preset format dictionary based on fingerprint features and output a predefined parsing template corresponding to the archive file if the match is successful;

[0050] The second recognition submodule is used to call the byte sequence analysis model based on deep learning when no match is successful, and automatically generate a structural description of the archive file;

[0051] Based on the predefined parsing template or structure description, the binary data stream is parsed to obtain the initial field set;

[0052] Perform field type mapping, index marking, and redundancy elimination on the initial field set to generate a structured data set.

[0053] Specifically, the following example uses the local archive file of "Game A" as the target and details how to complete the entire process of archive format recognition, structure description generation, and field-level structured parsing in the cloud. This example relies on object storage services, a serverless computing platform, and deep learning inference services.

[0054] When a player completes an incremental save by encrypting and uploading it, Object Storage generates an "object created" event. This event triggers the serverless compute instance (Function Service). The Function Service calls the Object Storage API to stream the complete binary data from the save, passing it directly to the next processing stage without storing it on the local disk.

[0055] The archive format recognition module consists of the first recognition submodule (fingerprint matching) and the second recognition submodule (deep analysis), which are executed in sequence.

[0056] In some examples, the first identification submodule: fingerprint matching, may include the following:

[0057] Fingerprint library construction: The platform pre-collects the header flags, magic numbers, fixed offset check bytes, and typical length distribution of common stand-alone game archives to form fingerprint entries, which are stored in a high-performance key-value database.

[0058] Matching process: read the first 4 KB bytes of the archive and several key offset bytes; calculate the hash fingerprint and search in the database; if the entry is hit, directly return the "predefined parsing template" associated with the fingerprint entry.

[0059] In some examples, the second recognition submodule: deep learning byte sequence analysis, may include the following:

[0060] When the fingerprint match fails, the in-depth analysis process begins:

[0061] Model architecture: This uses 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."

[0062] Inference steps: The entire binary stream is sliced ​​and used as model input; the model outputs the field number and inferred type (integer, floating point, UTF-8 string, compressed block, etc.) to which each byte belongs; a machine-readable "structure description file" is generated, which internally presents the field name, starting offset, length, data type, and nested relationship in JSON-Schema format.

[0063] Furthermore, if the first submodule has output a predefined parsing template, the parsing engine extracts each field according to the field order, data type and byte width listed in the template, and parses multi-byte values ​​in little-endian or big-endian mode.

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

[0065] Furthermore, if the field type is marked as "compressed block" or "nested structure", the parsing engine recursively calls itself. For compressed blocks, it first decompresses them according to the inferred compression algorithm (such as LZ4 or ZSTD) and then parses them. For nested structures, it treats the substructures as new parsing units and continues to perform field boundary recognition and decoding.

[0066] The platform maintains a "universal field semantic library" and performs fuzzy matching on the original fields obtained through parsing (such as value_01, flag_07) with the semantic library, mapping them to unified names (such as "character level", "task progress", and "item list").

[0067] Fields whose semantics cannot be determined are marked as "unknown fields" and accompanied by confidence levels for subsequent manual calibration or continuous training.

[0068] Furthermore, a unique index key of {game ID} / {version number} / {field path} is generated for each field and written into the index database for easy subsequent queries and difference calculations. For array or list fields, the number of elements and offset index are additionally recorded to enable random access.

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

[0070] Encapsulates the processed field set into a hierarchical JSON document and generates a binary Protocol-Buffer version for efficient transmission.

[0071] The JSON document is written to a NoSQL document database and indexed using the multi-dimensional "user ID - game ID - archived version" approach. The Protocol-Buffer file is stored in object storage and associated with the "binary backup path" recorded in the JSON document.

[0072] After the parsing results are written successfully, the "data available" event is triggered for real-time consumption by the subsequent multimodal feature fusion and difference calculation modules.

[0073] For example, in one example, after Game A's save file was uploaded, it was not found in the fingerprint library. The system automatically invoked the deep learning analysis model and identified 60 first-level fields, including three compressed packages and five nested lists.

[0074] After decompressing the compressed package, the character attribute table, level status table, and inventory table were obtained. After field semantic mapping, param_05 in the character attribute table was mapped to "Character Experience Points" with a confidence level of 0.92; item_17 in the inventory was mapped to "Rare Weapon" with a confidence level of 0.88.

[0075] During the redundancy elimination phase, it was found that the snapshot segment appeared 4 times, 3 of which had the same content. Only the latest one was retained to improve parsing efficiency.

[0076] The final structured data document is approximately 18% of the original archive size and contains complete high-semantic fields such as "character status", "level node", and "backpack items", providing an accurate data source for subsequent progress vector and gameplay vector extraction.

[0077] Through the method of the above embodiment, the cloud platform can automatically identify, parse at the field level, and uniformly structure stand-alone game archives from different sources, different formats, and even unknown formats without manual reverse engineering, providing a reliable high-dimensional data foundation for personalized archive recommendation algorithms and significantly reducing the cost of new game access.

[0078] In some embodiments, performing text feature extraction based on a structured data set to generate a text feature vector includes:

[0079] determining at least one text field from the structured data set as an analysis object;

[0080] Perform preprocessing on the text field, input the preprocessed subword sequence into the text embedding submodule, and use the vocabulary corresponding to the target game corpus to map each subword into an embedding vector sequence;

[0081] The embedding vector sequence is input into the context encoding submodule, which outputs field-level context representation based on a multi-layer self-attention mechanism;

[0082] Aggregation operations are performed on the field-level context representation to generate text feature vectors corresponding to the archived files.

[0083] Specifically, in this embodiment, after obtaining the structured dataset archived for Game A, the cloud-based parsing service first traverses the schema description of the dataset. During the traversal process, the service screens potential text fields using a dual strategy of field type tagging and content statistics: on the one hand, it determines whether the field declaration type is string; on the other hand, it samples and detects the average length of the field and the proportion of non-ASCII characters. When these indicators simultaneously meet the threshold requirements, the field is added to the "candidate text field" set. Subsequently, based on the priority specified in the business configuration file, the system determines semantically intensive fields such as plot dialogues, task notes, and user-defined tags as the final analysis objects to ensure that subsequent feature extraction focuses on the text fragments most relevant to user preferences.

[0084] Furthermore, to mitigate interference caused by capitalization, special symbols, and different encoding formats, each piece of text to be processed undergoes a unified preprocessing pipeline. This pipeline first performs UnicodeNFKC normalization on the original character sequence, then removes control characters and zero-width spaces. It also uses regular expressions customized based on gaming terminology to retain high-value substrings such as equipment names and skill abbreviations. The preprocessed text is then fed into a subword segmenter, which uses a 30,000-word BPE model trained offline on a composite corpus containing text from hundreds of single-player games. This model can treat complex meaning fragments such as "excalibur" and "hp potion" as stable subwords, thus avoiding semantic dilution caused by segmentation. The subword sequence output by the segmenter is encoded as a fixed-length ID sequence for subsequent embedding mapping.

[0085] In some examples, the text embedding submodule is responsible for mapping the above ID sequence into a dense vector sequence. This submodule loads a set of 256-dimensional pre-trained subword vectors and appends a special tag [CLS] to the input sequence to carry global semantics. To account for variations in sequence length, the system injects relative position information through positional encoding, enabling the model to distinguish between word order swaps in "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 to avoid sparse vectors caused by frequently occurring unknown words.

[0086] The context encoding submodule is implemented based on a six-layer Transformer encoder, each layer of which contains multi-head self-attention, feedforward network, LayerNorm and residual connection. In order to fully explore long-distance dependencies, the number of attention heads is set to 8, and the key dimension and numerical dimension are both 64. During the inference phase, the encoder will share weights for archives in the same batch to achieve high-throughput parallel processing. The field-level context representation output by the encoder is extracted in the last layer, where the [CLS] vector at position 0 naturally aggregates the global semantics. However, in order to further highlight the key information, this embodiment introduces a learnable query vector to perform attention pooling on the entire sequence. The query vector is jointly optimized with the recommendation model during offline training, and can dynamically adjust the contribution of each subword to the final representation.

[0087] After the aggregation operation is complete, the system generates a 256-dimensional text feature vector. This vector is then written to the feature index through L2 normalization and stored together with other types of features in the same archive (such as level progress vectors and item distribution vectors), providing a unified vectorized input for the difference measurement model. To support subsequent online retrieval, this embodiment simultaneously generates an inverted key during the writing phase. The key value is derived from the vector through locality-sensitive hashing projection, enabling coarse screening of similar vectors in milliseconds.

[0088] By maintaining an end-to-end consistent corpus and vector space in the combined process of text field screening, subword-level embedding, Transformer context encoding, and attention aggregation, this embodiment effectively improves the accuracy of capturing the semantic features of archived text. Compared with methods that rely solely on keywords or TF-IDF, the vector can more accurately reflect deep information such as task context, character status, and player choices, thereby significantly improving matching relevance and personalization in subsequent difference measurement and archive recommendation stages.

[0089] In some embodiments, collecting historical gaming behavior data of a target user and generating a user portrait vector corresponding to the target user includes:

[0090] Obtain multi-source game behavior records corresponding to the target user from the local terminal and the associated game platform server;

[0091] Perform time normalization and feature screening on multi-source game behavior records to build a behavior feature set;

[0092] Input the behavioral feature set into the portrait vectorization model, embed and encode various behavioral features according to the preset weight strategy, and use the vector aggregation algorithm to generate the user portrait vector;

[0093] The user portrait vector is associated with the corresponding target user identification information and stored for subsequent multi-dimensional difference measurement model calls.

[0094] Specifically, the platform first uses the terminal synchronization component to read the player's local log files on their personal computer. These log files are generated by Game A's launcher and runtime monitoring module. They contain entries such as daily play time, recently loaded level numbers, frequently used character classes, and the number of times quick bar items are clicked. After parsing the log files, the synchronization component temporarily stores key fields in a buffer.

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

[0096] Merged activity records must be time-normalized before entering the vectorization process. The platform uses a unified Universal Time Coordinated Time (UTC), mapping local timestamps from different sources to UTC. For overlapping date lines across time zones, an interval window algorithm is used to eliminate duplicate game time.

[0097] The system then performs feature filtering on the behavioral fields according to pre-set relevance rules: fields that directly reflect game engagement (such as weekly cumulative playtime) are assigned a high weight; fields closely related to gameplay preferences (such as melee skill usage frequency) are retained; and fields with low relevance to subsequent recommendations (such as window minimization times) are eliminated. This screening results in a behavioral feature set consisting of approximately twenty indicators, each represented by a uniformly sized numerical value or category.

[0098] Furthermore, the platform loads a user profile vectorization model into the model inference service, using the aforementioned behavioral feature set as input. For numerical features, the model uses interval normalization and maps them directly to a continuous vector space. For categorical features, the model references a pre-trained embedding matrix to convert discrete labels into dense vectors of fixed dimension.

[0099] The system then uses a gated fusion network to perform a weighted superposition of the embeddings in each dimension based on the category weights set in the strategy file. A vector aggregation algorithm (including average pooling and principal component dimensionality reduction) is then used to generate a 128-dimensional user profile vector. This vector is logically divided into two parts: the first half primarily represents the player's overall activity and progression tendency, while the second half shows the player's preference for various gameplay elements such as combat, exploration, and collection.

[0100] The generated user profile vector is written to the vector database along with the target player's unique ID. This database supports dual indexing by "player ID - latest generation time" and retains the previous three historical versions for easy backtracking. After a vector entry is successfully inserted, the system immediately triggers a callback, pushing the storage address of the new vector to the difference measurement service for use in the next round of archive recommendation calculations.

[0101] Through the above-mentioned continuous, closed-loop processing flow, this embodiment realizes the unified aggregation of players' multi-source historical behaviors, embedded coding of weight control, and efficient persistent storage, providing reliable and real-time updated user portrait data for subsequent personalized archive recommendations based on difference.

[0102] In some embodiments, based on the text feature vector and the user profile vector, a multi-dimensional difference measurement model is used to calculate the difference value of each candidate archive relative to the target user, including:

[0103] Get the progress vector and gameplay vector corresponding to each candidate archive;

[0104] In the multidimensional difference measurement model, the progress difference components between the progress vectors and the gameplay difference components between the gameplay vectors are calculated according to the preset distance function;

[0105] According to the weight configuration strategy, the progress difference component and the gameplay difference component are weighted and integrated to obtain the total difference value corresponding to the candidate archive;

[0106] The total difference value is associated with the candidate archive identifier and cached for subsequent sorting to generate an archive recommendation list.

[0107] Specifically, in a recommendation calculation for a player of "Game A," the cloud scheduling service first initiates a search command from the vector database, batch-retrieving 200 candidate save files uploaded within the past 72 hours. For each save file, the system simultaneously obtains two sets of numerical vectors: a 256-dimensional progress vector describing level progress and mission completion, and a 128-dimensional gameplay vector reflecting combat style and exploration preferences.

[0108] At the same time, the scheduling service loads the target player's corresponding progress vector and gameplay vector into the same memory context. To ensure comparability between data sets, the platform performs L2 normalization on all dimensions during the vector extraction phase, so no further processing is required here.

[0109] Furthermore, the difference measurement stage is completed in parallel on the GPU node by a dedicated multi-dimensional vector calculation module. For the progress dimension, the system uses Euclidean distance as the preset distance function: the module compares the progress vectors of the candidate archives, calculates the difference element by element and takes the square and 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 that is inversely proportional to the chapter weight to amplify the difference to prevent data holes from causing the progress difference to be underestimated. For the gameplay dimension, the platform uses "one minus cosine similarity" as the distance function: the module first calculates the cosine similarity between the candidate archive gameplay vector and the user portrait vector, and then uses one minus this value to obtain the gameplay difference component, where the larger the value, the more significant the difference.

[0110] After independently calculating the two components, the weighted fusion module applies the weighting according to the policy file issued by the configuration center. By default, the progress difference component is weighted 60%, and the gameplay difference component is weighted 40%. If the target player's profile shows the "Adventure and Exploration" tag, the policy file will increase the gameplay weight to 50%, reflecting the player's sensitivity to gameplay style matching.

[0111] The module calculates the total difference between each candidate save and the target player using a weighted average. This value, along with the save's unique identifier, is packaged into a key-value pair and written to a high-performance memory cache. The key is in the format "session ID - candidate save ID," and the value includes the progress difference component, the gameplay difference component, and the total difference. The cache is valid for 30 minutes to support multiple iterations and rapid re-ranking of the current recommended session.

[0112] Subsequently, the sorting service pulls all cache entries at once, sorts them from small to large according to the total difference, and returns the top 20 archives with the lowest difference to the client as the list to be pushed; at the same time, the results of the split of progress difference and gameplay difference are visualized as a radar chart, allowing players to intuitively understand the distance between each recommended archive and their own status.

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

[0114] In some embodiments, after sending the archive recommendation list to the target user terminal, the method further includes:

[0115] When the target user terminal receives the archive recommendation list, it obtains the incremental difference package of the corresponding candidate archive according to the user instruction;

[0116] After backing up the original archive of the target user, inject the incremental difference package into the target user's local archive directory;

[0117] After the injection is completed, the archive integrity check is performed. If the check fails, the original archive is restored.

[0118] Specifically, for example, in an actual application scenario for players of game A, after the cloud recommendation service completes the sorting of candidate archives, it pushes an archive recommendation list containing twenty items 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 incremental differential package download address, the differential package size, 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 distribution network. To ensure the integrity of the data during transmission, TLS 1.3 is enabled on the link between the client and the CDN. The digital signature is verified immediately after the download is complete. If the signature verification fails, the process is terminated and the user is prompted.

[0119] Before officially injecting the differential packet, the client ensures that Game A is not currently running using a file handle locking mechanism. It then copies the player's existing original save file to a "backup" subfolder within the same save directory, appending a timestamp and a random number to the file name to prevent overwriting the old backup. After the copy is complete, the SHA-256 hash of the original file is recalculated and written to the local log for subsequent rollback verification.

[0120] The differential package file uses the BSDiff format and is generated offline by the cloud when generating the recommended list, using the player's current save as the "old version" and the candidate save as the "new version." Therefore, the client only needs to locally call the differential merge engine to perform the patch operation on the original save. During the merge process, the differential engine first decompresses the differential package and compares the baseline version number with the version number recorded in the local original save. If the two do not match, the injection is automatically abandoned and the backup is restored. Once the verification is successful, the differential engine applies the patch in byte-block order, generating a new target save file and writing it back to the original save path.

[0121] After writing back, the client immediately calculates the SHA-256 of the new file and compares it with the target hash included in the differential package. If the hash values ​​match, the injection is successful, the client deletes the previously created backup file, and a "Synchronization Successful" prompt appears on the interface. If the hash values ​​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 recalculates the hash to confirm that the state before the injection has been restored. At the same time, the client uploads the error code and log to the cloud fault analysis service.

[0122] Throughout the entire process, the client sets timeout and retry policies for key steps: If digital signature verification fails, the process is immediately aborted; if differential merging fails after three retries, the patch is abandoned and a backup is retained; a hash verification failure triggers a single rollback. If the rollback succeeds, the message "Recovered" is logged; if the rollback also fails, the process enters a safety lock state and prompts the user for manual intervention. This backup, injection, verification, and rollback mechanism ensures that player saves can seamlessly update their progress during personalized synchronization, without losing or corrupting existing data due to abnormal operations.

[0123] The following are device embodiments of the present application, which can be used to implement the method embodiments of the present application. For details not disclosed in the device embodiments of the present application, please refer to the method embodiments of the present application.

[0124] Figure 2 This is a structural diagram of a stand-alone game archive personalized recommendation device based on intelligent archive analysis provided by an embodiment of the present application. Figure 2 As shown, the stand-alone game archive personalized recommendation device based on intelligent archive analysis includes:

[0125] The transmission module 201 is used to locate and read the archive files of the stand-alone game, transmit the archive files to the cloud storage via an encrypted link, and attach integrity verification information during the upload process;

[0126] The parsing module 202 is used to perform archive format recognition and structured parsing operations on the archive file after the cloud receives the archive file to obtain a structured data set;

[0127] Extraction module 203, used to extract text features based on the structured data set and generate text feature vectors;

[0128] A generation module 204 is used to collect historical gaming behavior data of a target user and generate a user portrait vector corresponding to the target user;

[0129] A calculation module 205 is used to calculate the difference value of each candidate archive relative to the target user based on the text feature vector and the user portrait vector using a multi-dimensional difference measurement model for the multiple candidate archives parsed in the cloud;

[0130] The sorting module 206 is configured to sort the candidate archives according to the difference values, generate an archive recommendation list, and send the archive recommendation list to the target user terminal.

[0131] In some embodiments, Figure 2 The transmission module 201 calls the operating system file management interface to traverse the local storage medium based on the preset archive path mapping rules to automatically locate the archive file corresponding to the target game identifier; when a write event is detected in the archive file, the change data is read and a data packet to be uploaded is generated according to a predetermined capture strategy.

[0132] In some embodiments, Figure 2 The parsing module 202 obtains the binary data stream of the archive file; inputs the binary data stream into the archive format recognition module, and the archive format recognition module includes: a first recognition submodule, which is used to match the preset format dictionary based on fingerprint features, and output a predefined parsing template corresponding to the archive file if the match is successful; a second recognition submodule, which is used to call the byte sequence analysis model based on deep learning when the match is not successful, and automatically generate a structural description of the archive file; based on the predefined parsing template or structural description, the binary data stream is parsed to obtain an initial field set; field type mapping, index marking and redundancy elimination processing are performed on the initial field set to generate a structured data set.

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

[0134] 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, embeds and encodes various behavior features according to the preset weight strategy, and uses the vector aggregation algorithm to generate a user portrait vector; the user portrait vector is associated with the corresponding target user identification information and stored for subsequent multi-dimensional difference measurement model call.

[0135] In some embodiments, Figure 2 The calculation module 205 obtains the progress vector and gameplay vector corresponding to each candidate archive; in the multidimensional difference measurement model, the progress difference component between the progress vectors and the gameplay difference component between the gameplay vectors are calculated according to the preset distance function; according to the weight configuration strategy, the progress difference component and the gameplay difference component are weightedly fused to obtain the total difference value corresponding to the candidate archive; the total difference value is associated with the candidate archive identifier and cached for subsequent sorting to generate an archive recommendation list.

[0136] In some embodiments, Figure 2 After the verification module 207 sends the archive recommendation list to the target user terminal, 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, the incremental differential package is injected into the local archive directory of the target user; after the injection is completed, the archive integrity check is performed, and if the check fails, the original archive is restored.

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

[0138] Figure 3 Schematic diagram of the structure of the electronic device 3 provided in the embodiment of the present application. Figure 3As 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, the steps of the above-mentioned method embodiments are implemented. Alternatively, when the processor 301 executes the computer program 303, the functions of the modules / units in the above-mentioned device embodiments are implemented.

[0139] For example, computer program 303 may be divided into one or more modules / units, which are stored in memory 302 and executed by processor 301 to implement the present application. One or more modules / units may 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 computer program 303 in electronic device 3.

[0140] The electronic device 3 may be a desktop computer, a notebook, a PDA, a cloud server or other electronic device. The electronic device 3 may include but is not limited to a processor 301 and a memory 302. Those skilled in the art will understand that Figure 3 It is only an example of electronic device 3 and does not constitute a limitation of electronic device 3. It may include more or fewer components than shown in the figure, or a combination of certain components, or different components. For example, the electronic device may also include input and output devices, network access devices, buses, etc.

[0141] The processor 301 may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA), 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.

[0142] Memory 302 can be an internal storage unit of electronic device 3, such as a hard drive or memory of electronic device 3. Memory 302 can also be an external storage device of electronic device 3, such as a plug-in hard drive, a Smart Media Card (SMC), a Secure Digital (SD) card, a flash memory card, etc. Furthermore, memory 302 can include both an internal storage unit of electronic device 3 and an external storage device. Memory 302 is used to store computer programs and other programs and data required by the electronic device. Memory 302 can also be used to temporarily store data that has been output or is about to be output.

[0143] Those skilled in the art can clearly understand that, for the convenience and brevity of description, only the division of the above-mentioned functional units and modules is used as an example for illustration. In actual applications, the above-mentioned functions can be distributed and completed by different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiment 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-mentioned integrated unit can be implemented in the form of hardware or in the form of software functional units. In addition, the specific names of the functional units and modules are only for the convenience of distinguishing each other, and are not used to limit the scope of protection of this application. The specific working process of the units and modules in the above-mentioned system can refer to the corresponding process in the aforementioned method embodiment, and will not be repeated here.

[0144] In the above embodiments, the description of each embodiment has its own focus. For parts that are not described or recorded in detail in a certain embodiment, reference can be made to the relevant description of other embodiments.

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

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

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

[0148] In addition, the functional units in the various embodiments of the present application may be integrated into a single processing unit, or each unit may exist physically separately, or two or more units may be integrated into a single unit. The aforementioned integrated units may be implemented in the form of hardware or software functional units.

[0149] 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, the present application can implement all or part of the processes in the above-mentioned embodiment method by instructing the 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, it can implement the steps of each of the above-mentioned method embodiments. The computer program may include computer program code, which may be in source code form, object code form, executable file, or some intermediate form. Computer-readable media may include: any entity or device capable of carrying computer program code, recording medium, USB flash drive, mobile hard disk, magnetic disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signal, telecommunication signal, and software distribution medium.

[0150] The above embodiments are only used to illustrate the technical solutions of the present application, rather than to limit them. Although the technical solutions of the present application are described in detail with reference to the aforementioned embodiments, those skilled in the art should understand that they can still modify the technical solutions described in the aforementioned embodiments, or make equivalent replacements for some of the technical features therein. These modifications or replacements do not deviate the essence of the corresponding technical solutions from the spirit and scope of the technical solutions of the various embodiments of the present application, and should all be included in the scope of protection of the present application.

Claims

1. A method for personalized recommendation of single-player game archives based on intelligent archive analysis, characterized in that: include: Locate and read the archive files of stand-alone games, transfer the archive files to cloud storage via an encrypted link, and attach integrity verification information during the upload process; When the cloud receives the archive file, it performs archive format recognition and structured parsing operations on the archive file to obtain a structured data set; Extracting text features based on the structured data set to generate a text feature vector; Collect historical gaming behavior data of target users and generate a user portrait vector corresponding to the target users; For multiple candidate archives parsed in the cloud, based on the text feature vector and the user portrait vector, a multi-dimensional difference measurement model is used to calculate the difference value of each candidate archive relative to the target user; The candidate archives are sorted according to the difference values, an archive recommendation list is generated, and the archive recommendation list is sent to a target user terminal.

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

3. The method according to claim 1, characterized in that The performing of archive format recognition and structured parsing operations on the archive file to obtain a structured data set includes: Obtaining a binary data stream of the archive file; The binary data stream is input into an archive format recognition module, wherein the archive format recognition module comprises: A first identification submodule is configured to match a preset format dictionary based on fingerprint features, and output a predefined parsing template corresponding to the archive file if the match is successful; A second identification submodule is configured to call a byte sequence analysis model based on deep learning to automatically generate a structural description of the archive file when no match is found; Based on the predefined parsing template or the structure description, performing field parsing on the binary data stream to obtain an initial field set; Field type mapping, index marking and redundancy elimination are performed on the initial field set to generate a structured data set.

4. The method according to claim 1, wherein The extracting text features based on the structured data set to generate a text feature vector includes: determining at least one text field from the structured data set as an analysis object; Performing a preprocessing operation on the text field, inputting the preprocessed subword sequence into a text embedding submodule, and mapping each subword into an embedding vector sequence using a vocabulary corresponding to the target game corpus; Input the embedding vector sequence into a context encoding submodule, which outputs a field-level context representation based on a multi-layer self-attention mechanism; An aggregation operation is performed on the field-level context representation to generate a text feature vector corresponding to the archive file.

5. The method according to claim 1, characterized in that The collecting of historical gaming behavior data of a target user and generating 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; Performing time normalization processing and feature screening on the multi-source game behavior records to construct a behavior feature set; Input the behavioral feature set into the portrait vectorization model, embed and encode various behavioral features according to a preset weight strategy, and use a vector aggregation algorithm to generate the user portrait vector; The user portrait vector is associated with the corresponding target user identification information and stored for subsequent multi-dimensional difference measurement model call.

6. The method according to claim 4, characterized in that The method of calculating the difference between each candidate archive and the target user using a multi-dimensional difference measurement model based on the text feature vector and the user portrait vector includes: Get the progress vector and gameplay vector corresponding to each candidate archive; In the multidimensional difference measurement model, the progress difference components between the progress vectors and the gameplay difference components between the gameplay vectors are calculated according to a preset distance function; According to the weight configuration strategy, the progress difference component and the gameplay difference component are weighted and merged to obtain a total difference value corresponding to the candidate archive; The total difference value is associated with the candidate archive identifier and cached for subsequent sorting to generate an archive recommendation list.

7. The method according to claim 1, characterized in that After sending the archive recommendation list to the target user terminal, the method further includes: When the target user terminal receives the archive recommendation list, it obtains the incremental difference package corresponding to the candidate archive according to the user instruction; After backing up the original archive of the target user, inject the incremental difference package into the local archive directory of the target user; After the injection is completed, the archive integrity check is performed. If the check fails, the archive is restored to the original archive.

8. A device for personalized recommendation of single-player game archives based on intelligent archive analysis, characterized in that: include: A transmission module, used to locate and read the archive files of stand-alone games, transmit the archive files to cloud storage via an encrypted link, and attach integrity verification information during the upload process; A parsing module is used to perform archive format recognition and structured parsing operations on the archive file after the cloud receives the archive file to obtain a structured data set; An extraction module, configured to extract text features based on the structured data set and generate a text feature vector; A generation module, configured to collect historical gaming behavior data of a target user and generate a user portrait vector corresponding to the target user; A calculation module, configured to calculate the difference value of each candidate archive relative to the target user based on the text feature vector and the user portrait vector using a multi-dimensional difference measurement model for the multiple candidate archives parsed in the cloud; A sorting module is used to sort the candidate archives according to the difference values, generate an archive recommendation list, and send the archive recommendation list to a target user terminal.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein: When the processor executes the computer program, the steps of the method according to any one of claims 1 to 7 are implemented.

10. A computer-readable storage medium storing a computer program, characterized in that: When the computer program is executed by a processor, the steps of the method according to any one of claims 1 to 7 are implemented.

Images