Method and system for improving performance of massive small files in distributed file system

Abstract

The invention discloses a method and system for improving the performance of massive small files under a distributed file system, and the method comprises the steps: when a request for opening a target small file is received, the request is sent to a private client, the client locates a metadata server and converts the request, and the metadata server returns the small file to the client for caching. And when the user service is read, a request is sent to the client, and the client returns the small file from the cache. According to the method, multiple interactions with the server are reduced, the network delay and the load of the server are reduced, and the operation performance and the user experience of the small file are remarkably improved.

Description

Technical Field

[0001] The present invention relates to the technical field of distributed file processing, and in particular to a method and system for improving the performance of massive small files in a distributed file system. Background Art

[0002] In a distributed file system, performance is often insufficient when processing massive small files. Each read and write of a small file requires multiple interactions with the metadata server and data server, resulting in high network latency and server load, which seriously affects the efficiency of file operations and user experience. Existing small file merging solutions have limitations and deficiencies and cannot effectively solve this problem. Summary of the invention

[0003] The object of the present invention is to provide a method and system for improving the performance of massive small files in a distributed file system.

[0004] In a first aspect, an embodiment of the present invention provides a method for improving the performance of massive small files in a distributed file system, comprising:

[0005] In response to a file opening request for opening a target small file, sending the file opening request to a private client corresponding to the distributed system;

[0006] Locating the metadata server where the target small file is located through the private client, and converting the file open request into an internal data request and sending it to the metadata server;

[0007] Returning the target small file to the private client through the metadata server, so that the private client caches the target small file;

[0008] In response to a file read request from a user service to read the target small file, sending the file read request to the private client;

[0009] The target small file is returned to the user service from the cache through the private client.

[0010] In a second aspect, an embodiment of the present invention provides a server system, including a server, wherein the server is used to execute the method described in the first aspect.

[0011] Compared with the prior art, the beneficial effects provided by the present invention include: using a method and system disclosed in the present invention to improve the performance of massive small files in a distributed file system, when a request to open a target small file is received, it is sent to a private client, the client locates the metadata server and converts the request, and the metadata server returns the small file to the client cache. When the user service reads, the request is sent to the client, and the client returns the small file from the cache. This method reduces multiple interactions with the server, reduces network latency and server load, and significantly improves the operational performance and user experience of small files. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings required for use in the embodiments are briefly introduced below. It should be understood that the following drawings only illustrate certain embodiments of the present invention and should not be regarded as limiting the scope. For those of ordinary skill in the art, other related drawings can also be obtained based on these drawings without creative work.

[0013] Figure 1 A schematic flow chart of the steps of a method for improving the performance of massive small files in a distributed file system provided by an embodiment of the present invention;

[0014] Figure 2 A schematic block diagram of the structure of a computer device provided in an embodiment of the present invention. DETAILED DESCRIPTION

[0015] In order to make the purpose, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Generally, the components of the embodiments of the present invention described and shown in the drawings here can be arranged and designed in various different configurations.

[0016] The specific implementation modes of the present invention are described in detail below in conjunction with the accompanying drawings.

[0017] In order to solve the technical problems in the aforementioned background technology, Figure 1 This is a flow chart of a method for improving the performance of massive small files in a distributed file system provided by an embodiment of the present disclosure. The method for improving the performance of massive small files in a distributed file system is introduced in detail below.

[0018] Step S201, in response to a file opening request for opening a target small file, sending the file opening request to a private client corresponding to the distributed system;

[0019] Step S202, locating the metadata server where the target small file is located through the private client, and converting the file open request into an internal data request and sending it to the metadata server;

[0020] Step S203, returning the target small file to the private client through the metadata server, so that the private client caches the target small file;

[0021] Step S204, in response to a file read request of a user service to read the target small file, sending the file read request to the private client;

[0022] Step S205: Return the target small file from the cache to the user service through the private client.

[0023] In an embodiment of the present invention, for example, there is a distributed file system for storing a large number of small files, such as pictures, documents, etc. The size of these small files is usually between tens of KB and several MB. For example, a user runs an application on his computer, such as image editing software, and needs to open a specific small picture file for editing. When the user chooses to open this picture file in the application, the operating system will generate an open file request. This request will be sent to the server. After the server receives this open file request, it will recognize that this is a request for a target small file in the distributed file system. The server immediately forwards this open file request to the private client (dfs-client) corresponding to the distributed system. After the private client (dfs-client) receives the open file request forwarded by the server, it will locate the metadata server (MetaServer) where the target small file is located through internal algorithms and metadata information. For example, there are multiple metadata servers in this distributed file system, and these metadata servers store metadata information of different small files according to certain rules. The dfs-client will determine the specific metadata server where the target small file is located by calculating or searching the corresponding mapping table based on the file's identification, path and other information. Once the target metadata server is determined, dfs-client converts the file open request received from the server into a data request in an internal specific format and sends it to the corresponding metadata server. After the metadata server receives the internal data request sent by dfs-client, it will first check the legitimacy and permissions of the request. If the request is legitimate and the user has the corresponding permissions, the metadata server will further determine whether the target small file meets the inline conditions. For example, the size of the target small file is less than the preset threshold (such as 1MB), meets the inline conditions, and its data has been stored locally on the metadata server. The metadata server will directly return the data of the target small file and the result of opening the file to dfs-client. After receiving the target small file returned by the metadata server, dfs-client will cache it in the local memory or cache so that it can respond to the user's read request faster in the future. The user starts to actually read the content of the small image file in the image editing software, and the operating system will generate a read file request and send it to the server. The server forwards this read file request to dfs-client again. After dfs-client receives the read file request forwarded by the server, it will check the local cache. Since the target small file has been cached before, it can directly obtain the data of the small file from the cache and return it to the server.The server then passes the data of this small file to the user's image editing software, and the user can quickly see the content of the small picture and perform editing or other operations.

[0024] For example, in another scenario, a user opens a small document file in a document processing software for reading. The same process will occur. The server will forward the file opening request and subsequent file reading request to the dfs-client. The dfs-client will interact with the metadata server to obtain the small file and cache it. Then, when receiving the read request, it will quickly return the file content from the cache, so that the user can read the document smoothly. For another example, in an enterprise resource management system, multiple users may need to access some small configuration files at the same time. When a user initiates a request to open and read these configuration files, the entire process still follows the above steps. Through the optimized solution, the concurrent small file access requirements of multiple users can be quickly met, improving the overall performance and response speed of the system. Through such an optimization solution, for massive small file access scenarios, it can significantly reduce multiple interactions with the metadata server and data server, reduce network latency and server load, greatly improve the opening and reading performance of small files, and provide users with a smoother and more efficient file access experience.

[0025] In the embodiments of the present invention, the following implementation modes are also provided.

[0026] In response to the user service executing a read-only file request for the target small file, in response to the user service's file closing request to close the target small file, returning a closing success to the user service through the private client, and asynchronously sending the file closing request to the metadata server;

[0027] In response to the user service executing a file modification request on the target small file, the file modification request is sent to the private client, and the private client sends the file modification request to the metadata server;

[0028] The metadata server updates the target small file according to the file modification request to obtain an updated target small file;

[0029] The metadata server returns the updated target small file to the private client, and the private client returns the updated target small file to the user service;

[0030] In response to a file closing request from a user service to close the updated target small file, a closing success is returned to the user service through the private client, and the file closing request is asynchronously sent to the metadata server.

[0031] In the embodiment of the present invention, for example, there is a document management system of an enterprise, which stores a large number of small files, including employee work reports, project plans, etc. Employee A opens a work report from last month, which is a small file. Employee A only wants to view the content and will not modify it. When employee A finishes reading and closes the file, the operating system generates a file closing request and sends it to the server. After receiving the file closing request, the server forwards it to the private client (dfs-client) corresponding to the distributed system. After receiving the request, dfs-client determines that this is a read-only file closing request, and immediately returns the result of successful closing to the application used by employee A. At the same time, dfs-client asynchronously sends the file closing request to the metadata server (MetaServer) in the background. After MetaServer receives the asynchronous closing request, since the file is read-only, no metadata needs to be updated, and the closing operation is simply recorded. Employee B is writing a new project plan, which is also a small file. During the writing process, employee B continuously performs modification and saving operations. When employee B modifies and saves, the operating system generates a file modification request and sends it to the server. The server forwards the file modification request to dfs-client. After receiving the request, dfs-client sends the modification request to MetaServer. After receiving the modification request, MetaServer updates the content of the target small file. For example, if employee B adds a new paragraph or modifies some data, MetaServer will apply these modifications to the file in a timely manner and update the relevant metadata, such as the modification time (mtime) and file size. After the update is completed, MetaServer returns the updated target small file to dfs-client. dfs-client then returns the updated small file to the application used by employee B so that employee B can see the latest modification results. When employee B finishes writing and closes the project plan, the operating system generates a file closing request and sends it to the server. The server forwards the request to dfs-client. After receiving the request, dfs-client directly returns the successful closure to employee B's application because the previous modification operation has made the file metadata up to date. At the same time, dfs-client asynchronously sends the closure request to MetaServer in the background. After receiving the asynchronous closure request, MetaServer confirms that the metadata does not need to be further updated and only records the closure operation.

[0032] For example, a scientific research team stores a large number of small files of experimental data records in its database. When researchers view previous data records (read-only) and close them, they follow the read-only closing process. When researchers add or modify experimental data records (modify) and close them, they follow the modification and closing process to ensure data accuracy and system performance optimization. Through such a process design, in the scenario where a distributed file system processes a large number of small files, the efficiency and performance of file operations can be greatly improved while ensuring data integrity and accuracy, meeting users' needs for fast file reading, writing and closing.

[0033] In the embodiments of the present invention, the following implementation modes are also provided.

[0034] In response to the user service executing a read-only file request for the target small file, calling a pre-trained target graph neural network model to determine a target pre-cached small file associated with the target small file;

[0035] The target pre-cached small file is sent to the private client through the metadata server for caching.

[0036] In an embodiment of the present invention, for example, there is an online education platform that contains a large number of small files, such as course materials, exercises, student homework, etc. When a student logs in to the platform and opens a small file material of a certain course for reading (read-only file request), the server receives this operation request. The server first determines that this is a read-only file request. Then, it calls the pre-trained target graph neural network model to determine the target pre-cached small file associated with the currently opened target small file. For example, this target small file is an explanation document about a certain mathematical knowledge point. Through the analysis of the target graph neural network model, it will find that the small file closely associated with this small file is the small file of the exercises in the same chapter, as well as the small files of the related basic concepts explained before. After determining these target pre-cached small files, the server will send instructions to the metadata server, requesting that these target pre-cached small files be sent to the private client. After receiving the instructions from the server, the metadata server obtains these target pre-cached small files from the storage and sends them to the private client. After receiving these target pre-cached small files, the private client caches them locally. For example, after reading the current mathematical knowledge point explanation document, the student wants to do some related exercises to consolidate the knowledge. Since the target graph neural network model has been used to predict and pre-cache the small files of the exercises in the same chapter, when the student clicks to open the exercises, the private client can quickly provide these small files from the local cache without having to request them from the metadata server again, which greatly reduces the waiting time and improves the efficiency and fluency of learning. For example, another student is viewing a small file about a historical event. The target graph neural network model will determine that the small file associated with this small file is an introduction to other relevant figures in the same period, or a small file analyzing different views of this historical event. These associated target pre-cached small files will be sent to the private client for caching according to the above process, so that students can quickly obtain them in the subsequent learning process without having to wait for a long time for data transmission. Through this mechanism, the server can intelligently predict and pre-cache related small files based on the user's read-only operation behavior, providing users with a faster and more convenient file access experience, especially in a distributed system that processes massive small files, which can significantly improve the system's performance and response speed.

[0037] In an embodiment of the present invention, the target graph neural network model is obtained in the following manner.

[0038] Obtain a first number of first relationship link instances and a second number of second relationship link instances, each of the first relationship link instances is used to describe the association between the user service instance and the small file instance when the user service instance is used as the initial node, and each of the second relationship link instances is used to describe the association between the small file instance and the user service instance when the small file instance is used as the initial node;

[0039] Extracting link feature representations of each of the first relationship link instances and link feature representations of each of the second relationship link instances;

[0040] Determine the link feature representation of the second number of the second relationship link instances as the original data of the small file network branch in the basic graph neural network model to obtain the small file instance feature representation, and determine the link feature representation of the first number of the first relationship link instances as the original data of the user service network branch in the basic graph neural network model, one of the small file instance feature representation or the first embedding vector, to obtain the user service instance feature representation, wherein the first embedding vector is used to describe the network parameters when the user service network branch learns the prediction result of the small file network branch;

[0041] The basic graph neural network model is trained according to the small file instance feature representation and the user business instance feature representation to obtain the target graph neural network model, and the target graph neural network model is used to process the link feature representation of a first number of first target relationship links and the link feature representation of a second number of second target relationship links to obtain a target small file feature representation and a target user business feature representation, and the target small file feature representation and the target user business feature representation are used to determine the target pre-cached small file.

[0042] In an embodiment of the present invention, for example, there is a large e-commerce platform that has a large number of small files of commodity information, including commodity detail pages, user reviews, commodity pictures, etc. The server needs to process a large number of user access requests to these small files to provide a fast and smooth shopping experience. The server first obtains a large number of relationship link instances. For example, 1,000 first relationship link instances and 2,000 second relationship link instances are obtained. The first relationship link instance may describe the association between a user and a specific commodity detail page small file when browsing a certain category of commodities (such as mobile phones). For example, user A searches for "mobile phone" and then clicks to view the small file of the detail page of a certain mobile phone of brand X. The second relationship link instance describes the association between the small file instance and the user business instance when the small file instance is used as the initial node. For example, a small file of the detail page of a popular mobile phone is clicked and viewed by a large number of users (such as user B, user C, etc.). The server then extracts the link feature representations of these relationship link instances. For the first relationship link instance, the features that may be extracted include the user's search keywords, browsing time, clicked commodity categories, etc. For the second relationship link instance, the features that may be extracted include the type of small file (whether it is a product details page or a user review), the frequency of being clicked, the length of time being viewed, etc. The server determines the link feature representation of the 2,000 extracted second relationship link instances as the original data of the "small file network branch" in the basic graph neural network model. Through the processing and calculation of the model, the small file instance feature representation is obtained. At the same time, the server will select the small file instance feature representation or a specific first embedding vector (a network parameter used to describe the user business network branch when learning the small file network branch prediction result), as well as the link feature representation of 1,000 first relationship link instances, as the original data of the "user business network branch" in the basic graph neural network model. The server trains the basic graph neural network model based on the obtained small file instance feature representation and user business instance feature representation. For example, when the server finds that after viewing the small file of the details page of a certain mobile phone (small file instance feature representation), the user often continues to view the details page of other models of mobile phones of the same brand (user business instance feature representation), and the model will learn this association pattern. For example, if many users check the related user reviews (another association pattern) after viewing the details page of a certain product, the model will also capture this pattern. By continuously adjusting the parameters of the model, the model can accurately predict the association between user behavior and small files. After multiple training and optimizations, the server finally obtained the target graph neural network model. This target graph neural network model can process the link feature representation of new relationship links (such as the first target relationship link and the second target relationship link) to obtain the target small file feature representation and the target user business feature representation. When a new user visits the e-commerce platform, the server uses this trained target graph neural network model.For example, after a new user enters the platform, he views the details page of a smart watch. Based on the previously learned association patterns and feature representations, the model predicts that the details page may be related to small files of watches of the same brand but different styles, or small files of FAQs about the watch, and determines these as target pre-cached small files. The server instructs the metadata server to send these target pre-cached small files to the private client for caching. In this way, when the user may want to view these related small files next, the private client can quickly provide them from the cache, greatly improving the user's access speed and shopping experience. To give another example, on an online music platform, the server obtains a large number of relationship link instances between user-played songs (user business instances) and song files (small file instances). By extracting features, determining network branch raw data, and training models, the model can learn that after listening to a popular song, the user will want to listen to other popular songs by the same singer, or songs of similar style. When a new user plays a popular pop song, the model predicts related target pre-cached small files, such as other songs by the singer, other songs of the same style, etc., and caches them in advance to provide users with a smoother music experience. On a news information platform, the server collects the relationship link instances between users reading news (user business instances) and news files (small file instances). The trained model can predict the small files such as related sports event reports and athlete interviews that users may be interested in after reading a certain sports news, and cache them in advance to reduce user waiting time and improve the reading experience. In this way, the server uses the target graph neural network model to more intelligently predict and cache related small files in the scenario of improving the performance of massive small files under the distributed file system, meet the potential needs of users, and improve the overall performance of the system and user satisfaction.

[0043] In an embodiment of the present invention, the small file network branch includes a first downsampling unit and a first weight allocation unit; the link feature representation of the second number of the second relationship link instances is determined as the original data of the small file network branch in the basic graph neural network model to obtain the small file instance feature representation, which can be implemented through the following example.

[0044] Loading the link feature representations of each second relationship link instance into the first downsampling unit respectively, obtaining the association feature representations of each second relationship link instance, where the association feature representations of each second relationship link instance are used to describe the mutual influence of the association of small files in the corresponding second relationship link instance;

[0045] Determine the associated feature representations of the second number of the second relationship link instances as the original data of the first weight allocation unit, and obtain the link weight coefficient of each of the second relationship link instances;

[0046] The first weight allocating unit performs linear superposition processing on the associated feature representations of the second number of the second relationship link instances and the link weight coefficient to obtain a small file instance feature representation.

[0047] In an embodiment of the present invention, for example, there is a large online library system, which contains a large number of small files of various types such as books and articles. The server needs to process a large number of readers' access requests to these small files to provide fast and efficient reading services. The server obtains a large number of link feature representations of second relationship link instances, for example, 5,000 second relationship link instances describing the association between readers' reading behavior and small files (such as chapters of a book) are obtained. These link feature representations are loaded into the first downsampling unit in the small file network branch respectively. For example, for a second relationship link instance, its link feature representation may include the reader's identity information, reading time, reading chapter content, etc. The first downsampling unit will process these features and analyze the association between the reader's reading of this chapter and other related chapters. After processing by the first downsampling unit, the association feature representation of each second relationship link instance is obtained. These association feature representations describe the mutual influence of the small file association in the corresponding second relationship link instance. For example, for a book about history, if the reader first reads the chapter on the political system of a certain dynasty, the first downsampling unit will analyze that he may be interested in the chapter on economic development or cultural characteristics of the same dynasty, thereby generating the corresponding association feature representation. The server determines the association feature representation of these 5,000 second relationship link instances as the original data of the first weight allocation unit. The first weight allocation unit will assign a link weight coefficient to each second relationship link instance based on these association feature representations. This coefficient reflects the importance of the link in predicting the reader's subsequent reading behavior. For example, if a certain association feature representation shows that the reader has a greater reading depth and a longer stay time on a certain chapter, then the corresponding link weight coefficient will be higher, indicating that this link is more important for predicting the reader's subsequent behavior. The server performs linear superposition processing on the association feature representation of these 5,000 second relationship link instances and the corresponding link weight coefficient according to the first weight allocation unit. Through this processing, the importance and mutual relationship of each link are comprehensively considered, so as to obtain a small file instance feature representation that can accurately reflect the association between small files and the reader's reading tendency. For example, through linear superposition processing, it is found that after reading a certain type of history book (such as ancient Chinese history), readers also show a certain interest in world history books of the same period. This small file instance feature representation can provide an important basis for the subsequent determination of pre-cached small files. For example, in another scenario, it is an online academic resource platform that contains a large number of small files such as academic papers and research reports. The server also obtains and processes a large number of second relationship link instances. For example, for a paper on artificial intelligence algorithms, its link feature representation can include the reader's academic background, reading purpose, other research that cites the paper, etc.After the first downsampling unit, the association between the reader's reading of this paper and other papers in related fields (such as machine learning, data mining) is analyzed. The first weight allocation unit allocates link weight coefficients to these associated feature representations, for example, a higher weight coefficient is given to other papers closely related to the current paper research method. Finally, the small file instance feature representation is obtained through linear superposition processing, so as to predict the related academic small files that the reader may want to read next, such as other research results of the same author, actual case analysis of the application of the algorithm, etc., and cache preparation is performed in advance to improve the efficiency of readers in obtaining academic resources. For example, on an online film and television platform, the second relationship link instance processed by the server can be a record of the audience's behavior of watching film and television works (small files). The link feature representation can include the audience's preference type, viewing time, whether to watch repeatedly, etc. The first downsampling unit analyzes the association between the audience's watching a certain film and other films, for example, the association with other works of the same director or films in the same series after watching a science fiction movie. The first weight allocation unit allocates weight coefficients to these associations, for example, different weights are given according to the audience's rating of the film. Through linear superposition processing, the small file instance feature representation is obtained, and other movies that the audience may be interested in are predicted and cached in advance, reducing the time the audience waits for buffering and improving the viewing experience. Through such a detailed and complex processing process, the server can more accurately mine the associations between small files and the potential needs of users in the scenario of improving the performance of massive small files under the distributed file system, providing users with better quality and faster services.

[0048] In the embodiment of the present invention, before the link feature representations of each second relationship link instance are loaded into the first downsampling unit respectively to obtain the associated feature representations of each second relationship link instance, the following implementation manner is also provided.

[0049] Acquire a second embedding vector, where the second embedding vector is used to describe a network parameter when the small file network branch learns a prediction result of the user service network branch;

[0050] Loading the link feature representations of each second relationship link instance into the first downsampling unit respectively to obtain the associated feature representations of each second relationship link instance includes:

[0051] Performing a feature merging operation on the second embedding vector and the link feature representation of each second relationship link instance, respectively, to obtain a merged feature representation of each second relationship link instance;

[0052] The merged feature representations of each second relationship link instance are loaded into the first downsampling unit respectively to obtain the associated feature representations of each second relationship link instance.

[0053] In an embodiment of the present invention, for example, in an environment of a large-scale online education platform, the platform has a large number of small course files, including video courses, document materials, exercises, etc. The server needs to efficiently handle students' access to these small files to ensure a high-quality learning experience. Before processing the relationship link between the small file and the user service, the server first obtains a second embedding vector. This second embedding vector is used to describe the network parameters when the small file network branch learns the prediction results of the user service network branch. For example, the server analyzes and learns a large amount of historical data to obtain a second embedding vector that can reflect the learning preferences and behavior patterns of students in different disciplines and different course stages. This vector contains information such as students' attention to theoretical knowledge and practical operations, and their acceptance of courses of different difficulty levels. The server obtains link feature representations of multiple second relationship link instances. For example, there are 8,000 such instances, each of which describes the association between a student (user service) and a specific course small file. For each link feature representation of the second relationship link instance, the server performs a feature merging operation with the acquired second embedding vector. For example, for a second relationship link instance, its link feature representation may include the student's current learning progress, the knowledge points that have been mastered, the type of course small file (whether it is a theoretical explanation or a case analysis), etc. The server merges these features with the second embedding vector. For example, the second embedding vector reflects that students are generally more interested in courses with practical cases, and the course small file in the current link feature representation is a document full of practical cases. Through the merging operation, this potential preference is combined with the specific link features to obtain a more comprehensive merged feature representation that better reflects the actual situation. The server loads these merged feature representations into the first downsampling unit respectively. The first downsampling unit will further process and analyze these merged feature representations. It will consider multiple factors, such as the access mode of different students to similar course small files at similar learning stages, the frequency change of the same course small file being accessed in different time periods, etc. After processing by the first downsampling unit, the server obtains the associated feature representations of each second relationship link instance. These associated feature representations reveal the mutual influence of the association of small files in each second relationship link instance in more depth. For example, for a small course file about mathematical functions, if multiple students at the same learning stage view this file and then view the related small files of exercises, then this association feature representation will highlight this association relationship, indicating that students have a high demand for related exercises when learning this knowledge point. For example, in another scenario, it is an online game platform, and the server needs to process the relationship links between players and various small files in the game (such as prop descriptions, task guides, map details, etc.).The server obtains the second embedding vector, which contains information such as the player's game style (aggressive or conservative), preferred game type (role-playing or strategy), etc. When processing the link feature representation of the second relationship link instance (such as the player's use of a specific prop in a certain level, the way to complete a specific task), it is merged with the second embedding vector. The first downsampling unit analyzes the association features between the player and other related small files (such as the strategy for subsequent levels, the way to obtain similar props) in the current game context based on the merged feature representation. In this way, the server can more accurately predict the small files that the player may need, and prepare and optimize them in advance to improve the fluency of the game and the satisfaction of the player. For another example, on an online medical consultation platform, the server processes the relationship links between doctors and small files such as patient medical records and diagnostic reports. The obtained second embedding vector may reflect the diagnostic habits of doctors in different departments, the characteristics of common diseases, etc. When processing the link feature representation of the second relationship link instance (such as a doctor's diagnosis process of a specific patient's condition and the relevant medical information consulted), a merge operation is performed. Based on the merged feature representation, the first downsampling unit obtains the association features between the doctor and other related small files (such as treatment plans for similar cases and the latest medical research results) when dealing with such conditions. In this way, the server can provide doctors with more timely and comprehensive information support and improve the quality and efficiency of medical services. In summary, by obtaining the second embedding vector and merging it with the link feature representation of the second relationship link instance, and then processing it by the first downsampling unit, the server can more accurately grasp the association between small files and user business needs in the scenario of improving the performance of massive small files under the distributed file system, and provide users with better quality and more efficient services.

[0054] In an embodiment of the present invention, the first weight allocation unit linearly superimposes the associated feature representations of the second number of the second relationship link instances with the link weight coefficient to obtain the small file instance feature representation, which can be implemented through the following examples.

[0055] According to the first weight allocation unit, linearly superimpose the associated feature representations of the second number of the second relationship link instances and the link weight coefficients to obtain a target merged feature representation;

[0056] A feature integration operation is performed on the target merged feature representation and the second embedding vector to obtain a small file instance feature representation.

[0057] In an embodiment of the present invention, for example, in an environment of a large online music platform, the platform has a large number of small music files, including songs, music albums, music reviews, etc. The server needs to efficiently process the interaction between users and these small files to provide high-quality music services. The server obtains a large number of associated feature representations and corresponding link weight coefficients of second relationship link instances. For example, there are 10,000 such instances. For each second relationship link instance, its associated feature representation can include information such as the user's music preferences (such as favorite music types, singers, eras, etc.), and the listening conditions of other music related to the current music file. The link weight coefficient reflects the importance of the associated feature in predicting the user's subsequent behavior. The first weight allocation unit will perform linear superposition processing on the associated feature representations of these 10,000 second relationship link instances based on these link weight coefficients. For example, for a certain user, if he often listens to a certain singer's songs and then listens to other popular songs of the singer, then the link weight coefficient of this associated feature representation will be higher. Through linear superposition processing, the server obtains a target merged feature representation by comprehensively considering all the associated feature representations and link weight coefficients. This target merged feature representation integrates the associated information between many users and small music files, and can preliminarily reflect the user's music listening mode and potential needs. The server performs a feature integration operation on the obtained target merged feature representation and the second embedding vector obtained previously. The second embedding vector contains information about the listening trends of the overall users of the music platform, the characteristics of popular music, etc. For example, the second embedding vector may reflect the style characteristics of current popular music, the general preference of users for a certain music element, etc. By integrating the target merged feature representation with the second embedding vector, the server can further enrich and improve the obtained features. For example, if the target merged feature representation shows that a user has a high degree of attention to a certain style of music, and the second embedding vector indicates that there are new popular works of this style of music released recently, then after the integration operation, it can be more accurately predicted that the user may be interested in these new works. Thus, a small file instance feature representation that can fully and accurately reflect the user's music preferences and potential needs is finally obtained. For example, in another scenario, it is an online film and television platform. The associated feature representation of the second relationship link instance obtained by the server may include the user's viewing history (favorite movie types, directors, actors, etc.), comments and sharing of a certain movie, etc. The link weight coefficient reflects the importance of these associated features. After the linear superposition processing of the first weight allocation unit, the target merged feature representation is obtained, which reflects the user's viewing habits and patterns. Then, it is integrated with the second embedding vector containing information such as popular film and television trends and audience distribution of different types of films.In this way, the server can more accurately predict new movies that users may be interested in, related small files around movies and TV shows (such as actor interviews, behind-the-scenes footage), etc., prepare these small files for users in advance, and improve the user's viewing experience. For example, on an online reading platform. The associated feature representation of the second relationship link instance may cover the user's reading preferences (favorite book types, authors, themes, etc.), reading time and notes on a certain book, etc. After obtaining the target merged feature representation through linear superposition, it is integrated with the second embedding vector containing information such as the popular trends of various books and topics that readers generally pay attention to. The final small file instance feature representation can help the server accurately recommend related books, articles and other small files to users to meet the user's reading needs. In summary, through the linear superposition processing of the first weight allocation unit and the feature integration operation with the second embedding vector, the server can deeply explore the complex relationship between users and small files in the scenario of improving the performance of massive small files under the distributed file system, provide users with more personalized and timely small file services, and improve the performance of the entire system and user satisfaction.

[0058] In an embodiment of the present invention, the user business network branch includes a second downsampling unit and a second weight allocation unit; the link feature representation of the first relationship link instances in the small file instance feature representation or the first embedding vector is determined as the original data of the user business network branch in the basic graph neural network model to obtain the user business instance feature representation, which can be implemented through the following example.

[0059] Perform a feature merging operation on the first embedding vector and the link feature representation of each first relationship link instance to obtain a first merged feature representation of each first relationship link instance;

[0060] Loading the first merged feature representations of each of the first relationship link instances into the second downsampling unit respectively, to obtain the associated feature representations of each of the first relationship link instances, where the associated feature representations of each of the first relationship link instances are used to describe the mutual influence of the user service association in the corresponding first relationship link instance;

[0061] Determine the associated feature representation of each of the first relationship link instances as the original data of the second weight allocation unit, and obtain the link weight coefficient of each of the first relationship link instances;

[0062] According to the second weight allocation unit, a linear superposition process is performed on the associated feature representations of the first number of the first relationship link instances and the link weight coefficient to obtain a first weight allocation feature representation;

[0063] A feature integration operation is performed on the first weight allocation feature representation and the first embedding vector to obtain a user service instance feature representation.

[0064] In an embodiment of the present invention, for example, in an environment of an e-commerce shopping platform, there are a large number of small files of commodity information on the platform, including commodity details, user reviews, purchase records, etc. The server needs to process a large number of user interactions with these small files to provide a high-quality shopping experience. The server obtains a first embedding vector, which contains information about the general pattern and trend of user shopping behavior, such as popular commodity categories in different seasons, consumer preferences of users of different age groups, etc. At the same time, the server also obtains link feature representations of multiple first relationship link instances, for example, there are 5,000 instances here. The link feature representation of each first relationship link instance can include the user's specific shopping behavior, such as the type of goods browsed, the goods added to the shopping cart, the searched keywords, etc. The server performs a feature merging operation on the first embedding vector and the link feature representation of each first relationship link instance. For example, for a first relationship link instance, its link feature representation shows that the user is browsing summer clothing, and the first embedding vector indicates that the current popular summer clothing style is simple style. Through the merging operation, a richer first merged feature representation is obtained, which can more comprehensively reflect the user's potential shopping needs. The server loads the first merged feature representations of each first relationship link instance into the second downsampling unit. The second downsampling unit processes and analyzes these first merged feature representations. It considers multiple factors, such as the shopping behavior of similar user groups in the same time period, the sales of the same product in different regions, etc. After processing by the second downsampling unit, the server obtains the associated feature representations of each first relationship link instance. These associated feature representations describe the mutual influence of user business associations in the corresponding first relationship link instance in more depth. For example, for a first relationship link instance where a user browses summer clothing, if other users with similar shopping behaviors immediately view related accessory products after browsing, then this associated feature representation will reflect this association, indicating that the user may also be interested in matching accessories when browsing summer clothing. The server determines the associated feature representations of each first relationship link instance as the original data of the second weight allocation unit. The second weight allocation unit allocates a link weight coefficient to each first relationship link instance based on these associated feature representations. This coefficient reflects the importance of the link in predicting the user's subsequent shopping behavior. For example, if a certain associated feature representation shows that the user has a greater browsing depth and a stronger willingness to buy a certain type of product, then the corresponding link weight coefficient will be higher, indicating that this link is more important for predicting the user's subsequent shopping behavior. The server performs linear superposition processing on the associated feature representations and link weight coefficients of the 5,000 first relationship link instances according to the second weight allocation unit to obtain the first weight allocation feature representation. Then, the first weight allocation feature representation is integrated with the first embedding vector.Through integration, the user's general shopping behavior pattern and specific shopping link features are combined to obtain a user business instance feature representation that can accurately reflect the user's shopping tendency and needs. For example, the user business instance feature representation may show that after browsing a certain electronic product, the user will pay more attention to its related peripheral accessories. The server can prepare relevant small files in advance, such as detailed introductions of accessories, discount information, etc., to improve the efficiency and satisfaction of user shopping. For example, in another scenario, it is an online travel booking platform. The first embedding vector contains information such as popular tourist destinations in different seasons and user travel preferences. The link feature representation of the first relationship link instance may include the tourist locations searched by the user, the hotel details viewed, the flight time booked, etc. After the steps of feature merging, second downsampling unit processing, second weight allocation unit processing, linear superposition and feature integration, the server can obtain the user business instance feature representation. This feature representation may indicate that after booking a hotel in a certain city, the user will query small files such as local tourist attraction tickets or transportation guides. The server can prepare in advance to optimize the user experience. For another example, on an online knowledge payment platform. The first embedding vector reflects the popularity of various knowledge courses, the user's learning preference trend, etc. The link feature representation of the first relationship link instance covers the course topics browsed by the user, the course duration watched, the content of the questions asked, etc. Through a series of processing, the user business instance feature representation finally obtained can help the server predict the relevant course small files that the user may be interested in next, such as advanced courses in the same field, lectures by relevant experts, etc., and prepare these small files in advance to improve the convenience of users to acquire knowledge. In summary, through the above series of processing steps, the server can accurately grasp the user's business needs in the scenario of improving the performance of massive small files under the distributed file system, and provide users with more intimate and efficient services.

[0065] In the embodiment of the present invention, the first merged feature representations of each of the first relationship link instances are loaded into the second downsampling unit respectively to obtain the associated feature representations of each of the first relationship link instances, which can be implemented through the following examples.

[0066] Extracting, from a first merged feature representation of a first relationship link, a feature representation of a target user service instance and feature representations of adjacent instances directly related to the target user service instance, wherein the first relationship link is any relationship link in the first number of first relationship link instances, and the target user service instance is any user service instance in the first relationship link;

[0067] Performing a multiplication operation on the feature representation of the target user service instance and the feature representation of each of the adjacent instances respectively, to obtain a weight coefficient instance of each of the adjacent instances in the first relationship link;

[0068] According to the weight coefficient instances of the adjacent instances, a linear superposition process is performed on the feature representations corresponding to the adjacent instances to obtain an associated feature representation of the first relationship link.

[0069] In an embodiment of the present invention, for example, in a large online news platform, there are a large number of news files, including various types of news reports, comments, special topics, etc. The server needs to process a large number of users' interactions with these news files to provide personalized news recommendation services. The server loads the first merged feature representations of multiple first relationship link instances into the second downsampling unit respectively. For each first relationship link instance, such as a link where user A browses news. From the first merged feature representation of this first relationship link, the feature representation of the target user business instance is extracted. For example, the target user business instance is a news report on the development of science and technology browsed by user A. At the same time, the feature representations of each adjacent instance that has a direct relationship with this target user business instance are also extracted, such as other news recommended on the same page as this science and technology news, or related news under the same topic. The server performs a multiplication operation on the feature representation of the target user business instance (science and technology news) and the feature representation of each adjacent instance (such as related recommended news). For example, the feature representation of the target user business instance contains information such as the browsing time of user A on science and technology news, whether to share, and comment content, and the feature representation of the adjacent instance contains the type, popularity, and release time of the news. Through the multiplication operation, the weight coefficient instance of each adjacent instance in the first relationship link is obtained. If user A stays on the technology news for a long time, and a certain adjacent financial technology news has a high correlation with the technology news, then the weight coefficient instance obtained by multiplying them will be larger, indicating that the user may have a high interest in this financial technology news. The server performs linear superposition processing on the feature representation of the corresponding adjacent instance according to the weight coefficient instance of each adjacent instance. For example, there are three adjacent news, namely financial technology news, technology enterprise dynamic news, and technology policy interpretation news, and their weight coefficient instances are 0.8, 0.6, and 0.4 respectively. The corresponding feature representation contains information such as the content summary, author, and source of the news. Through linear superposition processing, the feature representations of these three news are weighted and summed according to the weight coefficient. The result is the associated feature representation of the first relationship link, which comprehensively reflects the degree of association and potential interest tendency of user A with these adjacent news after browsing the technology news. For example, in another scenario, it is an online learning platform. For the first relationship link instance of user B watching a mathematics course video. The feature representation of the target user's business instance (the math course video) and the feature representation of the adjacent instances related to it are extracted from the first merged feature representation, such as exercises in the same chapter, videos explaining related knowledge points, etc. The associated feature representation of the first relationship link is obtained by calculating the weight coefficient instance and linear superposition processing.If user B has watched the math course video repeatedly, and the weight coefficient instance of the exercise questions is high, it means that the user may need to practice and consolidate immediately; if the weight coefficient instance of the video explaining the relevant knowledge points is high, it means that the user may have a need to expand knowledge. For another example, on an online social platform. For the first relationship link instance of a status posted by user C. Extract the feature representation of the target user's business instance (the status) and the feature representation of adjacent instances, such as friends' comments, likes, etc. After calculation and processing, the obtained associated feature representation can reflect the influence of user C's status in the social network and the closeness of related interactions, thereby providing data support for the server, such as deciding whether to recommend this status to more friends or display it in a popular area. In summary, through such detailed processing steps, the server can accurately mine the user's potential needs and interest tendencies when facing massive small files and complex user business relationships, provide users with more accurate and personalized services, and improve the performance and user experience of the distributed file system.

[0070] In the embodiments of the present invention, the following implementation modes are also provided.

[0071] Calculating a first mean absolute error between the user service instance feature representation and the second embedding vector;

[0072] The first embedding vector and the second embedding vector are optimized according to the first mean absolute error.

[0073] In an embodiment of the present invention, for example, in a large online picture sharing platform, the server needs to process a large number of small picture files and the user's browsing, collection, commenting and other operations on these pictures. The server first obtains the user business instance feature representation through a series of previous processing steps. This feature representation comprehensively reflects the user's picture operation behavior and preferences on the platform. At the same time, the server also has a second embedding vector, which contains information about the popular trends of the overall picture types on the platform, the general preferences of different user groups, etc. The server begins to calculate the first mean absolute error between the user business instance feature representation and the second embedding vector. For example, the user business instance feature representation shows that user A is mainly interested in landscape pictures and tends to browse high-definition and colorful landscape pictures. The second embedding vector reflects that character pictures on the current platform are more popular and generally prefer retro tones. The server calculates the absolute error value between the two vectors by comparing the differences in dimensions such as picture type and color preference. Then, multiple such error values ​​are averaged to obtain the first mean absolute error. According to the calculated first mean absolute error, the server optimizes the first embedding vector and the second embedding vector. If the first mean absolute error is large, it means that the user's personal preference is quite different from the overall trend of the platform. The server will adjust the first embedding vector to more accurately reflect the unique image preference of user A, such as increasing the weight of the relevant features of landscape images. At the same time, the server will also optimize the second embedding vector based on this error to make it more comprehensively reflect the diverse preferences of users on the platform, such as appropriately increasing the weight of landscape images in the overall popular trend. Through such optimization, when user A visits the platform next time, the server can more accurately recommend small landscape image files that meet his personal preferences, and at the same time make the overall recommendation strategy of the platform more in line with the actual needs of users, improve user experience and platform service quality, thereby improving the performance of the distributed file system when processing massive small image files. For example, in the scenario of an online document storage platform. The user business instance feature representation shows that user B frequently accesses technical documents and pays more attention to the latest published documents. The second embedding vector reflects that most users on the platform prefer to consult classic industry reports. The server calculates the first mean absolute error between the two and optimizes the embedding vector accordingly. It will enhance the embodiment of technical documents and the latest published features in the first embedding vector, and adjust the second embedding vector to more balanced reflect the needs of different types of documents. In this way, the server can more efficiently provide user B with the required small technical document files, optimize the platform's management and recommendation of various types of documents, and improve the performance of the entire system.

[0074] In the embodiments of the present invention, the following implementation modes are also provided.

[0075] Calculating a second mean absolute error between the small file instance feature representation and the first embedding vector;

[0076] The second embedding vector and the first embedding vector are optimized according to the second mean absolute error.

[0077] In an embodiment of the present invention, for example, in a large online video platform, the server needs to process a large number of small video files, including various types of movies, TV series, short videos, etc., as well as user operations such as playing, pausing, collecting, and commenting on these videos. The server first obtains the small file instance feature representation through the previous processing flow, which reflects the association and potential demand between the user and the specific video small file. At the same time, the server also has a first embedding vector, which contains information about the overall trend of video content on the platform, the general preferences of user groups, etc. The server begins to calculate the second mean absolute error between the small file instance feature representation and the first embedding vector. For example, the small file instance feature representation shows that user A has frequently watched science fiction movies recently, and has shown a clear preference for science fiction movies with high frame rates and rich special effects. The first embedding vector reflects that comedy movies are more popular on the current platform, and users generally pay more attention to the cast of the movie. The server calculates the absolute error value of each dimension by comparing the differences between the two vectors in dimensions such as movie type, video quality preference, and actor attention, and then averages these error values ​​to obtain the second mean absolute error. According to the calculated second mean absolute error, the server optimizes the first embedding vector and the second embedding vector. If the second mean absolute error is large, it means that user A's specific preferences are significantly different from the overall trend of the platform. The server will adjust the first embedding vector to more accurately reflect user A's preferences for science fiction movies and specific video quality, such as increasing the weight of related features such as science fiction movie types and high frame rate special effects. At the same time, the server will also optimize the second embedding vector based on this error so that it can more comprehensively cover the user's diverse preferences, such as appropriately increasing the weight of science fiction movies in the overall popular trend to better balance the attention of different types of movies. Through such optimization, when user A visits the platform next time, the server can more accurately recommend science fiction movie small files that meet his preferences, and at the same time make the platform's recommendation strategy more in line with the actual needs of the majority of users, improve user experience and platform service quality, thereby effectively improving the performance of the distributed file system when processing massive video small files. For example, in the scenario of an online music platform. The small file instance feature representation shows that user B always listens to classical music, especially piano concertos, and prefers lossless sound quality versions. The first embedding vector reflects that the platform has a higher listening volume of pop music, and users generally pay more attention to the lyrics of the songs. The server calculates the second mean absolute error between the two and optimizes accordingly. It will enhance the first embedding vector’s representation of features such as classical music, piano concertos, and lossless sound quality, while adjusting the second embedding vector to more reasonably reflect the distribution of different music types and user needs. In this way, the server can more efficiently provide user B with his favorite small classical music files, and can also optimize the platform’s push and management of various types of music, improving the performance of the entire system.

[0078] In an embodiment of the present invention, the user business network branch includes a third number of joint learning units, a boundary condition learning unit and an average pooling unit; the link feature representation of the first relationship link instance of the small file instance feature representation or one of the first embedding vectors and the first number of the first relationship link instances are determined as the original data of the user business network branch in the basic graph neural network model to obtain the user business instance feature representation, which can be implemented through the following example.

[0079] Loading the link feature representation of each of the first relationship link instances and the third number of joint learning vectors into the third number of joint learning units, obtaining the third number of preference vectors of each of the first relationship link instances, each of the joint learning units outputting one of the preference vectors, each of the joint learning vectors being used to represent the preference degree of the corresponding joint learning unit for the small file instance;

[0080] Loading the third number of preference vectors of each of the first relationship link instances, the third number of joint learning vectors, and the small file instance feature representation into the boundary condition learning unit to obtain a second merged feature representation of each of the first relationship link instances;

[0081] The second merged feature representations of a first number of the first relationship link instances are loaded into the average pooling unit to obtain the user service instance feature representation.

[0082] In an embodiment of the present invention, for example, in a large online game platform, there are a large number of game-related small files on the platform, including game strategies, character introductions, game patches, etc. The server needs to handle a large number of player interactions with these small files. The server obtains link feature representations of multiple first relationship link instances, for example, there are 2,000 instances here. Each link feature representation contains information such as the player's game behavior, game progress, and selected game characters. At the same time, the server also has a third number (for example, 5) of joint learning vectors. The link feature representation of each first relationship link instance and the 5 joint learning vectors are loaded into the corresponding 5 joint learning units. For example, for a first relationship link instance, its link feature representation shows that the player is playing a role-playing game, has reached a certain level, and is exploring a specific area. The joint learning unit will output 5 preference vectors based on this information and the joint learning vector. The preference vector output by each joint learning unit represents the unit's preference for small file instances (such as equipment strategies for a specific level, monster weakness introductions in the area, etc.). For example, the first joint learning unit has a higher preference for equipment strategies, and the output preference vector value is larger; the second joint learning unit has a lower preference for monster weakness introductions, and the output preference vector value is smaller. The server loads the 5 preference vectors, 5 joint learning vectors, and small file instance feature representations (such as the features of current popular games) of each first relationship link instance into the boundary condition learning unit. The boundary condition learning unit will integrate this information and perform more complex analysis and processing. For example, for a first relationship link instance, if its preference vector shows a high demand for equipment strategies and skill upgrade guides, and the joint learning vector and small file instance feature representation indicate that there are important updates to these two aspects of the current game, then the boundary condition learning unit will generate a second merged feature representation that can reflect this comprehensive information. This second merged feature representation more comprehensively reflects the potential demand and importance of players for related small files in the current game state. The server loads the second merged feature representations of these 2,000 first relationship link instances into the average pooling unit. The average pooling unit will average these feature representations. For example, it calculates the average value of the 2,000 second merged feature representations in each dimension to obtain a user business instance feature representation that can represent the general needs and behavior patterns of the entire player group in the current game environment. Through this feature representation, the server can better predict small files that players may need, such as preparing new gameplay introductions for popular games, notifications of upcoming game activities, etc. in advance, and cache them to improve the speed and experience of players obtaining information. For example, in another scenario, it is an online education platform. The link feature representation of the first relationship link instance includes students' learning courses, learning progress, homework completion status, etc.The joint learning vector may represent the attention paid to different types of learning materials (such as knowledge point explanation videos, exercises, and case studies). After being processed by the joint learning unit and the boundary condition learning unit, the second merged feature representation of each student is obtained, and then the user business instance feature representation that can reflect the learning needs of the entire student group is obtained through the average pooling unit. Based on this feature representation, the server can cache small files such as review materials for popular courses and the latest interpretation of the exam syllabus in advance to improve system performance. For example, in the scenario of an online shopping platform. The link feature representation of the first relationship link instance covers the user's shopping history, browsed product categories, shopping cart contents, etc. The joint learning vector can represent the degree of preference for different product attributes (such as brand, price, material). Through a series of processing, the user business instance feature representation finally obtained can help the server prepare small files such as promotional information of popular products and similar product recommendations in advance, speed up the user's information acquisition speed when shopping, and optimize the shopping experience. In summary, through the collaborative work of the joint learning unit, the boundary condition learning unit and the average pooling unit, the server can more accurately grasp the user's business needs and achieve more efficient small file management and service provision in the scenario of improving the performance of massive small files in the distributed file system.

[0083] In an embodiment of the present invention, loading the link feature representations of the first number of the first relationship link instances and the third number of joint learning vectors into the third number of joint learning units to obtain the third number of preference vectors of the first relationship link instances includes:

[0084] Extracting a feature representation of a target user service instance and a feature representation of each adjacent instance directly related to the target small file instance from a link feature representation of a second relationship link, wherein the second relationship link is any relationship link in the first number of first relationship link instances, and the target user service instance is any small file instance in the second relationship link;

[0085] Performing feature integration operations on the feature representations of the target user service instances and the third number of the joint learning vectors to obtain a third number of first integrated vectors;

[0086] Perform multiplication operations on the third number of the first integrated vectors and the feature representation of each of the adjacent instances respectively, to obtain a weight coefficient instance of each of the adjacent instances in the second relationship link;

[0087] According to the weight coefficient instances of the adjacent instances, linear superposition processing is performed on the feature representations corresponding to the adjacent instances to obtain a third number of preference vectors of the second relationship link.

[0088] In an embodiment of the present invention, for example, in a large online film and television platform, the server needs to process a large number of film and television related small files, including movies, dramas, trailers, film reviews, etc., as well as user interactions with these small files. The server obtains a large number of link feature representations of first relationship link instances, for example, the first number is 5000. For any second relationship link (such as user A's viewing link), extract the feature representation of the target user business instance from its link feature representation (for example, it is a science fiction movie that user A is watching), and the feature representation of each adjacent instance that has a direct relationship with the target small file instance (such as other works of the same director, other films with the same starring actors, popular films of the same type, etc.). The server performs feature integration operations on the feature representation of the target user business instance and the third number (for example, 3) of joint learning vectors. For example, the feature representation of the target user business instance may include information such as the type of film, duration, and user viewing progress. The joint learning vector may represent the attention to the complexity of the plot, visual effects, and actor acting skills, respectively. Through the feature integration operation, 3 first integrated vectors are obtained. For example, the first joint learning vector focuses on the complexity of the plot. After being integrated with the feature representation of the target user business instance, the first integrated vector obtained reflects the comprehensive evaluation of user A on the complexity of the plot of the current movie being watched. The server performs multiplication operations on the three first integrated vectors with the feature representations of each adjacent instance. The feature representation of the adjacent instance can include evaluations of the complexity of the plot, visual effects, and acting skills of the adjacent movie. Through the multiplication operation, the weight coefficient instance of each adjacent instance in the second relationship link is obtained. For example, if the first integrated vector indicates that user A has a high evaluation of the complexity of the plot of the current movie, and the plot complexity of a certain adjacent movie is also high, then the weight coefficient instance obtained by multiplying them will be larger, indicating that user A may have a high interest in this adjacent movie. The server performs linear superposition processing on the feature representation of the corresponding adjacent instance according to the weight coefficient instance of each adjacent instance. For example, there are 5 adjacent movies, namely, movies B, C, D, E, and F, and their corresponding weight coefficient instances are 0.7, 0.5, 0.3, 0.2, and 0.1, respectively. The feature representation of the adjacent instance includes information such as the introduction, rating, and comments of the movie. Through linear superposition processing, the feature representations of these five adjacent films are weighted and summed according to the weight coefficients. Finally, the three preference vectors of the second relationship link are obtained, which respectively reflect the preference of user A for adjacent films in terms of plot complexity, visual effects, and actor acting skills. For example, in another scenario, it is an online music platform. For user B's song listening link, the feature representation of the target user's business instance (a popular song being listened to) and the feature representation of adjacent instances that are directly related to this song (other songs by the same singer, popular songs of similar styles, etc.) are extracted.By operating with three joint learning vectors (representing preferences for melody, lyrics, and arrangement, respectively), calculating weight coefficient instances and performing linear superposition processing, three preference vectors reflecting user B's preferences for adjacent songs in terms of melody, lyrics, and arrangement are obtained. Based on these preference vectors, the server can cache small files of songs that may be of interest to user B in advance to improve the fluency of music playback and user experience. For another example, in the scenario of an online reading platform. For the reading link of user C, extract the feature representation of the target user's business instance (a novel being read) and the feature representation of adjacent instances (other works by the same author, popular novels of the same type, etc.). Perform corresponding operations with three joint learning vectors (representing attention to plot, writing style, and theme, respectively), and obtain three preference vectors reflecting user C's preferences for adjacent novels in terms of plot, writing style, and theme. Based on these preference vectors, the server prepares small files of related novels in advance to meet users' reading needs and improve system performance. In summary, through the above detailed processing steps, the server can accurately mine the user's potential interests and preferences when faced with massive small files and complex user business relationships, provide users with better and more personalized services, and effectively improve the performance of the distributed file system when processing massive small files.

[0089] In an embodiment of the present invention, the third number of preference vectors of each of the first relationship link instances, the third number of joint learning vectors and the small file instance feature representation are loaded into the boundary condition learning unit to obtain the second merged feature representation of each of the first relationship link instances, which can be implemented through the following example.

[0090] For each of the first relationship link instances, multiplying the third number of the joint learning vectors by the small file instance feature representation to obtain a weight coefficient of each of the preference vectors in each of the first relationship link instances;

[0091] For each of the first relationship link instances, a linear superposition process is performed on the corresponding third number of the preference vectors according to the weight coefficients of the third number of the preference vectors to obtain a second merged feature representation of each of the first relationship link instances.

[0092] In an embodiment of the present invention, for example, in a large online e-commerce platform, the server needs to process a large number of commodity-related small files, including commodity detail pages, user reviews, commodity recommendations, etc., as well as user interactions with these small files. The server obtains multiple first relationship link instances. For each first relationship link instance (such as user A's shopping link), the server performs a multiplication operation on the third number (for example, 3) of joint learning vectors and the small file instance feature representation (for example, the features of the current popular commodity). For example, the joint learning vectors represent the degree of attention to commodity price sensitivity, brand preference, and functional requirements, respectively, and the small file instance feature representation contains information about the price range, brand awareness, functional characteristics, etc. of the popular commodity. Through the multiplication operation, the weight coefficient of each preference vector is obtained. For example, if user A is usually more sensitive to price, and the price of the current popular commodity has a greater advantage, then the weight coefficient obtained by multiplying the joint learning vector corresponding to the price sensitivity with the small file instance feature representation will be larger. For each first relationship link instance, the server performs a linear superposition process on the corresponding preference vector according to the weight coefficients of the three preference vectors calculated. For example, for the shopping link of user A, the three preference vectors are preference for discounted products, preference for well-known brand products, and preference for products with specific functions, and their corresponding weight coefficients are 0.6, 0.3, and 0.1, respectively. Through linear superposition processing, the three preference vectors are weighted and summed according to the weight coefficients. Finally, the second merged feature representation of the first relationship link instance of user A is obtained. This second merged feature representation comprehensively considers the various preferences of user A and the characteristics of current popular products, and more comprehensively reflects the potential needs and tendencies of user A in the current shopping scenario. For example, in another scenario, it is an online travel booking platform. For the travel planning link of user B, the joint learning vector can represent the concerns about the safety of the destination, the popularity of tourist attractions, and the price of accommodation. The small file instance feature representation includes the situation of popular tourist destinations in these aspects. By calculating the weight coefficient and linear superposition processing, the second merged feature representation of user B is obtained, reflecting his comprehensive preference and demand for tourism products. According to this feature representation, the server can prepare small files such as travel route recommendations and discount event notifications that may be of interest to user B in advance, so as to improve the user's booking experience and the service efficiency of the platform. For another example, in the scenario of an online financial service platform. For user C's investment and financial management link, the joint learning vector can represent the attention to investment risk tolerance, expected returns, and investment period. The small file instance feature representation covers the characteristics of various financial products in these aspects. After corresponding processing, the second merged feature representation of user C is obtained, which helps the server to more accurately push suitable small files such as financial product introductions and market dynamics analysis to user C, meet the user's financial management needs, and improve the system's performance and response speed.In summary, by performing the above processing on the joint learning vector, small file instance feature representation and preference vector, the server can deeply explore the needs of users when facing massive small files and complex user business relationships, provide users with more accurate and personalized services, effectively improve the performance of the distributed file system when processing massive small files, and enhance user satisfaction and dependence on the platform.

[0093] In the embodiment of the present invention, the link feature representations of each second relationship link instance are loaded into the first downsampling unit respectively to obtain the associated feature representations of each second relationship link instance, which can be implemented through the following examples.

[0094] Extracting a feature representation of a target small file instance and feature representations of adjacent instances directly related to the target small file instance from a link feature representation of a third relationship link, wherein the third relationship link is any relationship link in the second number of second relationship link instances, and the target small file instance is any small file instance in the third relationship link;

[0095] Performing a multiplication operation on the feature representation of the target small file instance and the feature representation of each of the adjacent instances respectively, to obtain a weight coefficient instance of each of the adjacent instances in the third relationship link;

[0096] According to the weight coefficient instances of the adjacent instances, linear superposition processing is performed on the feature representations corresponding to the adjacent instances to obtain the associated feature representation of the third relationship link.

[0097] In an embodiment of the present invention, for example, in a large online course platform, the server needs to process a large number of course-related small files, including course videos, courseware, homework, etc., as well as the interaction between users and these small files. The server obtains a large number of link feature representations of the second relationship link instances, for example, the second number is 8000. For any third relationship link therein (such as a link for user A to learn a certain course), the feature representation of the target small file instance is extracted from its link feature representation (for example, a course video of a certain chapter that user A is learning), and the feature representation of each adjacent instance that has a direct relationship with the target small file instance (such as the pre-sequence chapter video, subsequent chapter video, related supplementary courseware, etc. of the same course). The server performs a multiplication operation on the feature representation of the target small file instance and the feature representation of each adjacent instance respectively. For example, the feature representation of the target small file instance can include information such as the duration of the course video, the user's viewing progress, and the number of views. The feature representation of the adjacent instance can include evaluations of the importance, relevance, and difficulty of the adjacent chapter video. Through the multiplication operation, the weight coefficient instance of each adjacent instance in the third relationship link is obtained. For example, if the target course video is a key chapter that user A has watched repeatedly and has a fast viewing progress, and a video of an adjacent chapter has a high correlation with the key chapter, then the weight coefficient instance obtained by multiplying them will be larger, indicating that user A may have a high degree of attention to this adjacent chapter video. The server performs linear superposition processing on the feature representation of the corresponding adjacent instance according to the weight coefficient instance of each adjacent instance. For example, there are 5 adjacent instances, namely the previous chapter video, the subsequent chapter video, the supplementary courseware A, the supplementary courseware B, and the related homework, and their corresponding weight coefficient instances are 0.7, 0.5, 0.3, 0.2, and 0.1 respectively. The feature representation of the adjacent instance contains information such as the main content of the chapter, the knowledge points of the courseware, and the difficulty of the homework. Through linear superposition processing, the feature representations of these 5 adjacent instances are weighted and summed according to the weight coefficients. Finally, the associated feature representation of the third relationship link is obtained, which reflects the degree of association and potential needs of user A with these adjacent instances when learning the current course video. For example, if the result of the linear superposition processing shows a high correlation with the subsequent chapter videos and related homework, the server can infer that user A may be about to enter the next stage of learning, and prepare relevant small files in advance, such as preview materials for subsequent chapters, answers to homework, etc., to improve the user's learning efficiency and experience. For example, in another scenario, it is an online knowledge question and answer platform. For the answer link (third relationship link) of a certain question, extract the feature representation of the target small file instance (the current best answer), as well as the feature representation of each adjacent instance that is directly related to the answer (such as answers to similar questions, related extended discussions, expert comments, etc.). Through the above calculation and processing steps, the associated feature representation of the relationship link is obtained.Based on this association feature representation, the server can recommend more relevant and valuable content to users, enhancing the interactivity and knowledge dissemination effect of the platform. For another example, in the scenario of an online picture library platform. For the link (third relationship link) of a user browsing a certain picture, the feature representation of the target small file instance (current picture) and the feature representation of each adjacent instance that has a direct relationship with this picture (such as other pictures of the same theme, pictures of similar styles, related picture descriptions, etc.) are extracted. After corresponding processing, the association feature representation is obtained. Based on this, the server can show users a collection of pictures that is more in line with their interests, improving the user's browsing experience and the attractiveness of the platform. In summary, through the above detailed and precise processing process, the server can deeply understand the complex relationship between users and small files in the scenario of improving the performance of massive small files under the distributed file system, provide users with more targeted and practical services, and significantly improve the performance of the system and user satisfaction.

[0098] In an embodiment of the present invention, the basic graph neural network model is trained according to the small file instance feature representation and the user business instance feature representation to obtain the target graph neural network model, which can be implemented through the following examples.

[0099] Calculating the deviation between the small file instance feature representation and the user service instance feature representation to obtain a target error parameter;

[0100] The parameters of the basic graph neural network model are optimized according to the target error parameters to obtain a target graph neural network model.

[0101] In an embodiment of the present invention, for example, in a large online news recommendation platform, the server needs to process a large number of small news files, including news articles of various types and themes, as well as user interactions with these news, such as browsing, liking, commenting, etc. The server has obtained the small file instance feature representation and the user service instance feature representation through the previous processing steps. The small file instance feature representation may include the subject, keywords, popularity and other features of the news article, while the user service instance feature representation reflects the user's interest preferences, reading history, behavior patterns, etc. The server begins to calculate the deviation between the small file instance feature representation and the user service instance feature representation. For example, the small file instance feature representation shows that the current hot news is about major breakthroughs in the field of science and technology, while the user service instance feature representation shows that users are usually more concerned about entertainment and sports news. By comparing the differences between the two feature representations in dimensions such as themes and keywords, the server calculates the deviation between them. This deviation may be reflected in multiple aspects, such as the mismatch degree of news topics, the low overlap of keywords, etc. The server combines these deviations to obtain a target error parameter, which quantitatively describes the mismatch degree between small files and user services. After obtaining the target error parameter, the server optimizes the parameters of the basic graph neural network model according to the error. For example, if the target error parameter is large, it means that the current prediction result of the model is quite different from the actual situation. The server will adjust the weight, bias and other parameters in the model so that the model can learn the relationship between small files and user services more accurately. For example, if a certain weight parameter in the model is too high, it will lead to excessive emphasis on certain news features. The server will reduce this weight to balance the influence of different features. For example, if a certain bias parameter is set unreasonably, the model will misunderstand certain types of user services. The server will adjust this bias to make the output of the model more in line with actual needs. By continuously optimizing parameters according to the target error parameter, the model can gradually capture the association between small files and user services more accurately. For example, after multiple optimizations, when new science and technology news appears, the model can accurately judge the user's interest in the news based on the user's historical behavior and interests, and recommend it more effectively to users who may be interested. For example, in another scenario, it is an online document sharing platform. The small file instance feature representation includes the document's subject, format, author, and other information, while the user business instance feature representation covers the user's work area, common document types, search history, and so on. The server calculates the deviation between them and obtains the target error parameter. Then, the model parameters are adjusted according to this error parameter so that the model can more accurately predict the user's needs for different documents.For example, if a user is mainly engaged in marketing work and often searches and browses marketing plan documents, and the model previously mistakenly recommends technical documents to the user, by optimizing the model parameters, this kind of wrong recommendation can be reduced, and the document recommendation that better fits the user's work needs can be provided. For another example, in the scenario of an online music recommendation platform. The small file instance feature representation includes the style, singer, release time, etc. of the song, and the user business instance feature representation reflects the user's music preferences, listening history, and favorite songs. The server calculates the deviation between the two to obtain the target error parameter and optimizes the model parameters accordingly. The optimized model can more accurately recommend songs that meet the user's taste, improve the accuracy and satisfaction of music recommendations, and thus improve the performance of the distributed file system when processing massive small music files. In summary, by calculating the deviation between the small file instance feature representation and the user business instance feature representation to obtain the target error parameter, and optimizing the basic graph neural network model based on the parameter, the server can continuously improve the performance of the model, better meet the needs of users in the massive small file scenario, and improve the overall efficiency and user experience of the system.

[0102] In an embodiment of the present invention, the target error parameter includes a focus error parameter.

[0103] In an embodiment of the present invention, for example, in a large online picture library platform, the server processes a large number of small picture files, covering various themes and styles, and serves the browsing, downloading, and collection operations of many users. When calculating the deviation between the small file instance feature representation and the user business instance feature representation to obtain the target error parameter, the focus error parameter plays an important role. For example, the small file instance feature representation can include the theme of the picture (such as scenery, people, animals, etc.), shooting techniques (such as close-up, panoramic, backlighting, etc.), color distribution and other features. The user business instance feature representation reflects the user's browsing history (frequently viewed picture themes), collection behavior (preferred shooting style), search keywords, etc. When the server calculates the focus error parameter, it will pay special attention to the focus aspects that the user is currently most concerned about or frequently operates. For example, in a certain period of time, users frequently search and browse pictures of specific themes (such as seascapes), and show a clear preference for seascape pictures with specific color styles (such as blue tones). However, among the small picture files recommended by the model, the proportion of pictures that meet these focus features is low or not accurate enough. The server determines the focus error parameter by comparing the difference between the user's focus demand and the actual recommendation result. If the proportion of blue tones in the recommended seascape picture is far lower than the user's expectations, or the recommended seascape picture does not match the user's preferences in key focus features such as shooting angle and clarity, a large focus error will be generated. Through the precise calculation and analysis of the focus error parameter, the server can more clearly understand the shortcomings of the model in meeting the user's specific focus needs, so as to optimize and improve the model in a targeted manner. For example, the server can adjust the weights related to the seascape picture features in the model, increase the weights of focus features such as blue tones and specific shooting angles, so as to improve the accuracy and pertinence of subsequent recommendations, enhance user experience, and optimize the performance of the distributed file system when processing massive image small files. For example, in an online course platform, the focus error parameter may be reflected in the user's high attention to a certain type of popular course (such as Python courses in programming languages) in a specific period, and the focus demand for specific course content (such as data analysis). By calculating the focus error parameters in this regard, the server can accurately optimize course recommendations and better meet the user's learning focus needs at a specific stage.

[0104] In the embodiment of the present invention, obtaining a first number of first relationship link instances and a second number of second relationship link instances may be implemented through the following example.

[0105] Acquire multivariate relationship network data, the multivariate relationship network data including a first number of the first relationship link instances and a second number of the second relationship link instances, the multivariate relationship network data being used to describe a multi-level interaction framework between the user service instance and the small file instance.

[0106] In an embodiment of the present invention, for example, in a large-scale online office software platform, the server needs to process a large number of small files, such as documents, tables, slides, etc., as well as various interactive operations between users and these small files. The server obtains multivariate relationship network data, which includes a first number of first relationship link instances and a second number of second relationship link instances. These data form a complex and comprehensive network for describing a multi-level interaction framework between user business instances and small file instances. For example, the server obtains 5,000 first relationship link instances and 8,000 second relationship link instances. In the first relationship link instance, the following situation may be included: User A opens a project planning document, spends a long time reading and editing, and saves and references related template files many times during the period. This link instance describes the interaction details of user A with a specific small file (planning document and template file) in a specific business scenario (project planning), including the time, frequency, sequence, etc. of the operation. The second relationship link instance may be as follows: A popular financial report template small file is frequently downloaded and modified by multiple different users (user B, user C, etc.) within a week, and the content and focus of each modification are different. This link instance shows the different operations and usage patterns of multiple users around the same small file. Through these multi-relationship network data, the server can fully understand the user's interaction with various small files in different business scenarios. For example, in another scenario, it is an online design platform. The first relationship link instance obtained by the server can be: Designer D opened a design material file of a specific style, and then performed a series of creations based on it, including color adjustment, element combination and other operations. The second relationship link instance can be: A newly released high-definition picture material small file was quickly paid attention to and used by many designers within a day, and each designer applied it in different ways and fields. These relationship link instances together constitute a rich multi-relationship network, reflecting the complex and diverse interactive relationship between user business (design work) and small file instances (material files). For another example, in the scenario of an online education platform. The first relationship link instance can be: Student E watched a video small file of a specific course, took detailed notes, and reviewed it many times after class. The second relationship link instance can be: A small file summarizing the key knowledge points of a certain chapter was accessed and printed by a large number of students before the exam. By collecting and analyzing such multi-relational network data, the server can deeply understand the user's learning behavior and demand patterns for small files, thereby better optimizing file storage, retrieval and recommendation, improving system performance, and providing users with more efficient and convenient services.

[0107] In summary, the first relationship link instance and the second relationship link instance in the multi-relationship network data obtained by the server provide rich and specific information for in-depth analysis of the interactive relationship between user services and small files, which helps the server make more accurate and effective decisions and optimizations in improving the performance of massive small files in a distributed file system.

[0108] The embodiment of the present invention provides a computer device 100, which includes a processor and a non-volatile memory storing computer instructions. When the computer instructions are executed by the processor, the computer device 100 executes the aforementioned method for improving the performance of massive small files in a distributed file system. Figure 2 As shown, Figure 2 The block diagram of the computer device 100 provided in the embodiment of the present invention. The computer device 100 includes a memory 111, a processor 112 and a communication unit 113. To achieve data transmission or interaction, the memory 111, the processor 112 and the communication unit 113 are directly or indirectly electrically connected to each other. For example, these components can be electrically connected to each other through one or more communication buses or signal lines.

[0109] For illustrative purposes, the foregoing description is made with reference to specific embodiments. However, the above illustrative discussion is not intended to be exhaustive or to limit the present disclosure to the precise form disclosed. Numerous modifications and variations are possible in accordance with the above teachings. These embodiments are selected and described in order to best illustrate the principles of the present disclosure and its practical application, so that those skilled in the art can best utilize the present disclosure and utilize various embodiments with different modifications to suit the intended specific application.

Claims

1. A method for improving the performance of massive small files in a distributed file system, characterized in that: include: In response to a file opening request for opening a target small file, sending the file opening request to a private client corresponding to the distributed system; Locating the metadata server where the target small file is located through the private client, and converting the file open request into an internal data request and sending it to the metadata server; Returning the target small file to the private client through the metadata server, so that the private client caches the target small file; In response to a file read request from a user service to read the target small file, sending the file read request to the private client; The target small file is returned to the user service from the cache through the private client.

2. The method according to claim 1, characterized in that The method further comprises: In response to the user service executing a read-only file request for the target small file, in response to the user service's file closing request to close the target small file, returning a closing success to the user service through the private client, and asynchronously sending the file closing request to the metadata server; In response to the user service executing a file modification request on the target small file, the file modification request is sent to the private client, and the private client sends the file modification request to the metadata server; The metadata server updates the target small file according to the file modification request to obtain an updated target small file; The metadata server returns the updated target small file to the private client, and the private client returns the updated target small file to the user service; In response to a file closing request from a user service to close the updated target small file, a closing success is returned to the user service through the private client, and the file closing request is asynchronously sent to the metadata server.

3. The method according to claim 1, characterized in that: The method further comprises: In response to the user service executing a read-only file request for the target small file, calling a pre-trained target graph neural network model to determine a target pre-cached small file associated with the target small file; The target pre-cached small file is sent to the private client through the metadata server for caching.

4. The method according to claim 3, characterized in that The target graph neural network model is obtained by the following methods, including: Acquire multi-relationship network data, the multi-relationship network data comprising a first number of first relationship link instances and a second number of second relationship link instances, the multi-relationship network data being used to describe a multi-level interaction framework between the user service instance and the small file instance, each of the first relationship link instances being used to describe an association between the user service instance and the small file instance when the user service instance is used as an initial node, and each of the second relationship link instances being used to describe an association between the small file instance and the user service instance when the small file instance is used as an initial node; Extracting link feature representations of each of the first relationship link instances and link feature representations of each of the second relationship link instances; Determine a small file network branch in the basic graph neural network model, wherein the small file network branch includes a first downsampling unit and a first weight allocation unit; Loading the link feature representations of each second relationship link instance into the first downsampling unit respectively, obtaining the association feature representations of each second relationship link instance, where the association feature representations of each second relationship link instance are used to describe the mutual influence of the association of small files in the corresponding second relationship link instance; Determine the associated feature representations of the second number of the second relationship link instances as the original data of the first weight allocation unit, and obtain the link weight coefficient of each of the second relationship link instances; According to the first weight allocation unit, a linear superposition process is performed on the associated feature representations of the second number of the second relationship link instances and the link weight coefficient to obtain a small file instance feature representation, and one of the small file instance feature representation or the first embedding vector and the link feature representation of the first number of the first relationship link instances are determined as the original data of the user business network branch in the basic graph neural network model to obtain the user business instance feature representation, wherein the first embedding vector is used to describe the network parameters when the user business network branch learns the prediction result of the small file network branch; Calculating the deviation between the small file instance feature representation and the user service instance feature representation to obtain a target error parameter; The parameters of the basic graph neural network model are optimized according to the target error parameters to obtain a target graph neural network model, and the target graph neural network model is used to process the link feature representation of a first number of first target relationship links and the link feature representation of a second number of second target relationship links to obtain a target small file feature representation and a target user business feature representation, and the target small file feature representation and the target user business feature representation are used to determine the target pre-cache small file.

5. The method according to claim 4, characterized in that Before loading the link feature representations of each second relationship link instance into the first downsampling unit to obtain the associated feature representations of each second relationship link instance, the method further includes: Acquire a second embedding vector, where the second embedding vector is used to describe a network parameter when the small file network branch learns a prediction result of the user service network branch; Loading the link feature representations of each second relationship link instance into the first downsampling unit respectively to obtain the associated feature representations of each second relationship link instance includes: Performing a feature merging operation on the second embedding vector and the link feature representation of each second relationship link instance, respectively, to obtain a merged feature representation of each second relationship link instance; Loading the merged feature representations of each of the second relationship link instances into the first downsampling unit respectively to obtain associated feature representations of each of the second relationship link instances; The step of performing linear superposition processing on the associated feature representations of the second number of the second relationship link instances and the link weight coefficients according to the first weight distribution unit to obtain the small file instance feature representation includes: According to the first weight allocation unit, linearly superimpose the associated feature representations of the second number of the second relationship link instances and the link weight coefficients to obtain a target merged feature representation; Performing a feature integration operation on the target merged feature representation and the second embedding vector to obtain a small file instance feature representation; The user service network branch includes a second downsampling unit and a second weight allocation unit; determining one of the small file instance feature representation or the first embedding vector and the link feature representation of the first number of the first relationship link instances as the original data of the user service network branch in the basic graph neural network model to obtain the user service instance feature representation, including: Perform a feature merging operation on the first embedding vector and the link feature representation of each first relationship link instance to obtain a first merged feature representation of each first relationship link instance; Extracting, from a first merged feature representation of a first relationship link, a feature representation of a target user service instance and feature representations of adjacent instances directly related to the target user service instance, wherein the first relationship link is any relationship link in the first number of first relationship link instances, and the target user service instance is any user service instance in the first relationship link; Performing a multiplication operation on the feature representation of the target user service instance and the feature representation of each of the adjacent instances respectively, to obtain a weight coefficient instance of each of the adjacent instances in the first relationship link; performing linear superposition processing on feature representations corresponding to the adjacent instances according to weight coefficient instances of the adjacent instances to obtain an associated feature representation of the first relationship link, wherein the associated feature representation of each first relationship link instance is used to describe the mutual influence of user service association in the corresponding first relationship link instance; Determine the associated feature representation of each of the first relationship link instances as the original data of the second weight allocation unit, and obtain the link weight coefficient of each of the first relationship link instances; According to the second weight allocation unit, a linear superposition process is performed on the associated feature representations of the first number of the first relationship link instances and the link weight coefficient to obtain a first weight allocation feature representation; A feature integration operation is performed on the first weight allocation feature representation and the first embedding vector to obtain a user service instance feature representation.

6. The method according to claim 5, characterized in that The method further comprises: Calculating a first mean absolute error between the user service instance feature representation and the second embedding vector; The first embedding vector and the second embedding vector are optimized according to the first mean absolute error.

7. The method according to claim 5, characterized in that The method further comprises: Calculating a second mean absolute error between the small file instance feature representation and the first embedding vector; The second embedding vector and the first embedding vector are optimized according to the second mean absolute error.

8. The method according to claim 4, characterized in that The user service network branch includes a third number of joint learning units, a boundary condition learning unit, and an average pooling unit; determining one of the small file instance feature representation or the first embedding vector and the link feature representation of the first number of the first relationship link instances as the original data of the user service network branch in the basic graph neural network model to obtain the user service instance feature representation, including: Extracting a feature representation of a target user service instance and a feature representation of each adjacent instance directly related to the target small file instance from a link feature representation of a second relationship link, wherein the second relationship link is any relationship link in the first number of first relationship link instances, and the target user service instance is any small file instance in the second relationship link; Performing feature integration operations on the feature representations of the target user service instances and the third number of the joint learning vectors to obtain a third number of first integrated vectors; Perform multiplication operations on the third number of the first integrated vectors and the feature representation of each of the adjacent instances respectively, to obtain a weight coefficient instance of each of the adjacent instances in the second relationship link; According to the weight coefficient instances of each of the adjacent instances, a linear superposition process is performed on the feature representations corresponding to the adjacent instances to obtain a third number of preference vectors of the second relationship link, each of the joint learning units outputs one of the preference vectors, and each of the joint learning vectors is used to represent the preference degree of the corresponding joint learning unit for the small file instance; For each of the first relationship link instances, multiplying the third number of the joint learning vectors by the small file instance feature representation to obtain a weight coefficient of each of the preference vectors in each of the first relationship link instances; For each of the first relationship link instances, linearly superimpose the corresponding third number of the preference vectors according to the weight coefficients of the third number of the preference vectors to obtain a second merged feature representation of each of the first relationship link instances; The second merged feature representations of a first number of the first relationship link instances are loaded into the average pooling unit to obtain the user service instance feature representation.

9. The method according to claim 4, characterized in that Loading the link feature representations of each second relationship link instance into the first downsampling unit respectively to obtain the associated feature representations of each second relationship link instance includes: Extracting a feature representation of a target small file instance and feature representations of adjacent instances directly related to the target small file instance from a link feature representation of a third relationship link, wherein the third relationship link is any relationship link in the second number of second relationship link instances, and the target small file instance is any small file instance in the third relationship link; Performing a multiplication operation on the feature representation of the target small file instance and the feature representation of each of the adjacent instances respectively, to obtain a weight coefficient instance of each of the adjacent instances in the third relationship link; According to the weight coefficient instances of the adjacent instances, linear superposition processing is performed on the feature representations corresponding to the adjacent instances to obtain the associated feature representation of the third relationship link.

10. A server system, characterized in that: The method comprises a server, wherein the server is used to execute the method described in any one of claims 1 to 9.

Images