A method and system for improving the performance of a large number of small files in a distributed file system

Abstract

The present invention discloses a method and system for improving the performance of a large number of small files in a distributed file system, including: when a request to open a target small file is received, it is sent to a private client, and the client locates the metadata server and converts the request, and the metadata server returns the small file to the client for caching. When the user's 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 operation performance of small files and the user experience.

Description

Technical Field

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

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

[0003] The purpose of the present invention is to provide a method and system for improving the performance of a large number of 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 a large number of small files in a distributed file system, including:

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

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

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

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

[0009] Returning, by the private client, the target small file from the cache to the user service.

[0010] In a second aspect, an embodiment of the present invention provides a server system, including a server, and 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: By adopting a method and system for improving the performance of a large number of small files in a distributed file system disclosed by the present invention, when a request to open a target small file is received, it is sent to a private client, and the client locates the metadata server and converts the request, and the metadata server returns the small file to the client for caching. When the user's 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 operation performance of small files and the user experience. BRIEF DESCRIPTION OF THE DRAWINGS

[0012] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings required for use in the embodiments will be briefly introduced below. It should be understood that the following drawings only show some 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 be obtained based on these drawings without creative efforts.

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

[0014] Figure 2 It is a schematic block diagram of the structure of a computer device provided by an embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0015] To make the objectives, 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 with reference to the drawings in the embodiments of the present invention. Obviously, the described embodiments are some, but not all, of the embodiments of the present invention. The components of the embodiments of the present invention described and illustrated herein can be arranged and designed in various different configurations.

[0016] The following will describe in detail the specific embodiments of the present invention with reference to the drawings.

[0017] To solve the technical problems in the foregoing background art, Figure 1 It is a schematic flow chart of a method for improving the performance of a large number of small files in a distributed file system provided by an embodiment of the present disclosure. The following will introduce in detail the method for improving the performance of a large number of small files in a distributed file system.

[0018] Step S201, in response to an open file request to open a target small file, send the open file request to a private client corresponding to the distributed system;

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

[0020] Step S203: Return the target small file from the metadata server to the private client so that the private client caches the target small file;

[0021] Step S204: In response to the read file request for reading the target small file by the user service, send the read file 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, by way of example, there is a distributed file system for storing a large number of small files, such as pictures, documents, etc. The sizes of these small files are generally between dozens 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 selects to open this picture file in the application, the operating system generates an open file request. This request is sent to the server. After receiving this open file request, the server recognizes 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 corresponding private client (dfs-client) of the distributed system. After receiving the open file request forwarded by the server, the private client (dfs-client) locates the metadata server (MetaServer) where this 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 the 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 looking up the corresponding mapping table based on information such as the file identifier and path. Once the target metadata server is determined, the dfs-client converts the open file request received from the server into a data request in a specific internal format and sends it to the corresponding metadata server. After receiving the internal data request sent by the dfs-client, the metadata server first checks the legality and permissions of this request. If the request is legal and the user has the corresponding permissions, the metadata server further determines whether this target small file meets the inlining condition. For example, the size of this target small file is less than a preset threshold (such as 1MB), meets the inlining condition, and its data has been stored locally on the metadata server. The metadata server directly returns the data of this target small file and the result of opening the file to the dfs-client. After receiving the target small file returned by the metadata server, the dfs-client caches it in local memory or cache for faster response to subsequent user read requests. When the user starts to actually read the content of this small picture file in the image editing software, the operating system generates a read file request and sends it to the server. The server forwards this read file request to the dfs-client again. After receiving the read file request forwarded by the server, the dfs-client checks the local cache. Since this target small file has been cached before, it can directly obtain the data of this small file from the cache and return it to the server.The server then transfers the data of this small file to the user's image editing software, enabling the user to quickly view the content of this small picture and thus perform editing or other operations.

[0024] For example, in another scenario, the user opens a small document file in a document processing software for reading. The same process will occur. The server will forward the open file request and subsequent read file requests 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, allowing the user to smoothly read the document. Another example is in an enterprise resource management system, where multiple users may need to access some small configuration files simultaneously. 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, it can quickly meet the concurrent small file access needs of multiple users, improving the overall performance and response speed of the system. Through such an optimized solution, for a large number of 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 open and read performance of small files, and provide a smoother and more efficient file access experience for users.

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

[0026] In the case of responding to the read-only file request of the user service for the target small file, in response to the close file request of the user service to close the target small file, return a close success to the user service through the private client, and asynchronously send the close file request to the metadata server;

[0027] In the case of responding to the modify file request of the user service for the target small file, send the modify file request to the private client, and the private client sends the modify file request to the metadata server;

[0028] Update the target small file by the metadata server according to the modify file request to obtain the updated target small file;

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

[0030] In response to the close file request of the user service to close the updated target small file, return a close success to the user service through the private client, and asynchronously send the close file request to the metadata server.

[0031] In an embodiment of the present invention, by way of example, for instance, there is a document management system of an enterprise, which stores a large number of small files, including work reports of employees, 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 this file, the operating system generates a file close request and sends it to the server. After receiving this file close request, the server forwards it to the corresponding private client (dfs-client) of the distributed system. After receiving the request, dfs-client determines that this is a close request for a read-only file and immediately returns a result indicating successful closure to the application used by Employee A. At the same time, dfs-client asynchronously sends this file close request to the metadata server (MetaServer) in the background. After receiving the asynchronous close request, since the file is read-only and no metadata needs to be updated, MetaServer simply records this close operation. Employee B is writing a new project plan, which is also a small file. During the writing process, Employee B continuously makes modifications and save operations. When Employee B makes a modification and saves, the operating system generates a file modification request and sends it to the server. The server forwards this file modification request to dfs-client. After receiving it, dfs-client sends this file 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, modifies some data, etc., MetaServer will promptly apply these modifications to the file and update 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, enabling Employee B to see the latest modification results. When Employee B finishes writing and closes this project plan, the operating system generates a file close request and sends it to the server. The server forwards the request to dfs-client. After receiving the request, since the previous modification operations have made the file metadata up-to-date, dfs-client directly returns a successful closure to Employee B's application. At the same time, dfs-client asynchronously sends the close request to MetaServer in the background. After receiving the asynchronous close request, MetaServer confirms that no further metadata update is required and simply records this close operation.

[0032] For another example, in the database of a scientific research team, a large number of small experimental data record files are stored. When researchers view the previous data records (read-only) and close them, they are processed according to the read-only close process. When researchers add or modify experimental data records (modify) and close them, they operate according to the modify and close process to ensure data accuracy and system performance optimization. Through such a process design, in the scenario of a distributed file system processing a large number of small files, it is possible to greatly improve the efficiency and performance of file operations while ensuring data integrity and accuracy, meeting the user's requirements for fast file reading, writing, and closing.

[0033] In the embodiments of the present invention, the following implementation manners are further provided.

[0034] In the case of responding to the read-only file request for the target small file by the user service, the pre-trained target graph neural network model is called to determine the target pre-cached small file associated with the target small file;

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

[0036] In an embodiment of the present invention, exemplarily, for example, there is an online education platform that contains a large number of small files, such as course materials, exercise questions, students' homework, etc. When a student logs in to the platform and opens a small file of a certain course for reading (a read-only file request), the server receives this operation request. The server first determines that this is a read-only file request. Then, it will call a pre-trained target graph neural network model to determine the target pre-cached small files associated with the currently opened target small file. For example, this target small file is an explanatory document about a certain mathematical knowledge point. Through the analysis of the target graph neural network model, it will be found that the small files closely associated with this small file are the exercise small files of the same chapter and the small files of relevant basic concepts explained previously. After determining these target pre-cached small files, the server will send an instruction to the metadata server, requesting the metadata server to send these target pre-cached small files to the private client. After receiving the server's instruction, the metadata server retrieves 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 a student finishes reading the current explanatory document about the mathematical knowledge point and wants to do some relevant exercises to consolidate the knowledge. Since the exercise small files of the same chapter have been predicted and pre-cached by the target graph neural network model before, when the student clicks to open the exercise questions at this time, the private client can quickly provide these small files from the local cache without having to request again from the metadata server, greatly reducing the waiting time and improving the learning efficiency and fluency. Another example is that another student is viewing a small file about a historical event. The target graph neural network model will determine that the small files associated with this small file are the introduction small files of other relevant figures in the same period or the small files of different viewpoints' analysis 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 during subsequent learning without waiting for a long time for data transmission. Through such a mechanism, the server can intelligently predict and pre-cache relevant small files according to the user's read-only operation behavior, providing a faster and more convenient file access experience for users. Especially in a distributed system dealing with a large number of small files, it can significantly improve the system 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 quantity of first relationship link instances and a second quantity 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 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 the initial node;

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

[0040] Determine the link feature representations of the second quantity 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 small file instance feature representations, and determine one of the small file instance feature representations or the first embedding vector and the link feature representations of the first quantity 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 user service instance feature representations. The first embedding vector is used to describe the network parameters when the user service network branch learns the prediction results of the small file network branch;

[0041] Train the basic graph neural network model according to the small file instance feature representations and the user service instance feature representations to obtain the target graph neural network model. The target graph neural network model is used to process the link feature representations of the first quantity of first target relationship links and the link feature representations of the second quantity of second target relationship links to obtain target small file feature representations and target user service feature representations. The target small file feature representations and the target user service feature representations are used to determine target pre-cached small files.

[0042] In an embodiment of the present invention, by way of example, for instance, there is a large e-commerce platform that has a vast number of small files of product information, including product detail pages, user reviews, product pictures, etc. The server needs to process a large number of access requests from users 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, it obtains 1000 first relationship link instances and 2000 second relationship link instances. The first relationship link instances may describe the association between a user when browsing a certain type of product (such as mobile phones) and the specific small file of the product detail page. For example, user A searches for "mobile phones" and then clicks to view the small file of the detail page of a certain mobile phone of brand X. The second relationship link instances describe the association between the small file instance as the initial node and the user business instance. For example, the small file of the detail page of a certain 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 instances, the possible extracted features include the user's search keywords, browsing time, clicked product category, etc. For the second relationship link instances, the possible extracted features include the type of the small file (whether it is a product detail page or a user review), the clicked frequency, the viewed duration, etc. The server determines the link feature representations of the 2000 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 either the small file instance feature representation or a specific first embedding vector (used to describe the network parameters when the user business network branch learns the prediction result of the small file network branch), and the link feature representations of the 1000 first relationship link instances, and determine them 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 a user views the small file of the detail page of a certain mobile phone (small file instance feature representation), they often then view the detail pages of other models of the same brand (user business instance feature representation), the model will learn this association pattern. Another example is that if many users, after viewing the detail page of a certain product, will then view the relevant user reviews (another association pattern), the model will also capture this rule. By continuously adjusting the parameters of the model, the model can accurately predict the association between user behavior and small files. After multiple trainings and optimizations, the server finally obtains the target graph neural network model. This target graph neural network model can process the link feature representations 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 accesses the e-commerce platform, the server uses this trained target graph neural network model.For example, after a new user enters the platform and views the details page of a smartwatch, the model predicts, based on the previously learned association patterns and feature representations, that the target pre-cache small files related to this details page could be the details page small files of watches of different models from the same brand, or the small files of frequently asked questions about the watch, etc., and determines these as the target pre-cache small files. The server will instruct the metadata server to send these target pre-cache 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. Take another example. On an online music platform, the server obtains a large number of relationship link instances between the songs played by the user (user service instances) and the song files (small file instances). By extracting features, determining the original data of the network branches, and training the model, the model can learn that after a user listens to a popular song, they will want to listen to other popular songs by the same singer or songs of a similar style. When a new user plays a certain popular song, the model predicts the relevant target pre-cache small files, such as other songs by the singer, other songs of the same style, etc., and caches them in advance to provide a smoother music experience for the user. On a news information platform, the server collects the relationship link instances between the news read by the user (user service instances) and the news files (small file instances). The trained model can predict the small files such as relevant sports event reports and athlete interviews that the user may be interested in after reading a certain sports news, and cache them in advance to reduce the user's waiting time and improve the reading experience. In this way, the server can use the target graph neural network model to more intelligently predict and cache relevant small files in the scenario of improving the performance of massive small files in a 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; determining the link feature representations of the second quantity 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 can be implemented through the following examples.

[0044] Loading the link feature representations of each of the second relationship link instances into the first downsampling unit respectively to obtain the association feature representations of each of the second relationship link instances, and the association feature representations of each of the second relationship link instances are used to describe the mutual influence situation of the small file associations in the corresponding second relationship link instance;

[0045] Determining the association feature representations of the second quantity of the second relationship link instances as the original data of the first weight allocation unit to obtain the link weight coefficients of each of the second relationship link instances;

[0046] According to the first weight allocation unit, perform a linear superposition process on the association feature representations of the second quantity of the second relationship link instances and the link weight coefficients to obtain the small file instance feature representation.

[0047] In an embodiment of the present invention, by way of example, there is a large online library system that contains a vast amount of various types of small files such as books, articles, etc. The server needs to process a large number of access requests from readers to these small files to provide fast and efficient reading services. The server obtains a large number of link feature representations of the second relationship link instances. For example, 5000 second relationship link instances that describe the association between readers' reading behaviors and small files (such as chapters of a certain book) are obtained. These link feature representations are respectively loaded into the first downsampling unit in the small file network branch. For example, for a certain second relationship link instance, its link feature representation may include the reader's identity information, reading time, read 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 being processed by the first downsampling unit, the association feature representations of each second relationship link instance are obtained. These association feature representations describe the mutual influence of the small file associations in the corresponding second relationship link instances. For example, for a history book, if a 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 chapters on the economic development or cultural characteristics of the same dynasty next, and thus generate corresponding association feature representations. The server determines the association feature representations of these 5000 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 according to these association feature representations. This coefficient reflects the importance of this link in predicting the reader's subsequent reading behavior. For example, if an association feature representation shows that the reader has a relatively deep reading depth and a long stay time for 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 a linear superposition process on the association feature representations of these 5000 second relationship link instances and the corresponding link weight coefficients according to the first weight allocation unit. Through this process, 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 the linear superposition process, it is found that after reading a certain type of history book (such as ancient Chinese history), the reader also shows a certain interest tendency in world history books of the same period. This small file instance feature representation can provide an important basis for the determination of subsequent pre-cached small files. For example, in another scenario, it is an online academic resource platform that contains numerous small files such as academic papers, research reports, etc. 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 may include the reader's academic background, reading purpose, other research that cites this paper, etc.After passing through the first downsampling unit, the associations between the reader's reading of this paper and other papers in related fields (such as machine learning and data mining) are analyzed. The first weight assignment unit assigns link weight coefficients to these association feature representations. For example, for other papers closely related to the research method of the current paper, higher weight coefficients are given. Finally, through linear superposition processing, the feature representation of the small file instance is obtained, so as to predict the relevant academic small files that the reader may want to read next, such as other research results of the same author, practical case analyses applying this algorithm, etc., and cache preparation is carried out in advance to improve the efficiency of the reader to obtain academic resources. Another example is on an online video platform, where the second relationship link instance processed by the server can be the behavior record of the audience watching video 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 associations between the audience's viewing of a certain film and other films. For example, the association situation with other works of the same director or films of the same series after watching a certain science fiction film. The first weight assignment unit assigns weight coefficients to these associations. For example, different weight values are given according to the audience's ratings of the films. Through linear superposition processing, the feature representation of the small file instance is obtained, predicting other films that the audience may be interested in, caching in advance, reducing the waiting time for the audience to buffer, 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 a distributed file system, and provide better and faster services for users.

[0048] In the embodiment of the present invention, before loading the link feature representations of the second relationship link instances into the first downsampling unit respectively to obtain the association feature representations of the second relationship link instances, the following implementation manners are also provided.

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

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

[0051] Performing an execution feature merging operation on the second embedding vector and the link feature representations of the second relationship link instances respectively to obtain the merged feature representations of the second relationship link instances;

[0052] Loading the merged feature representations of the second relationship link instances into the first downsampling unit respectively to obtain the association feature representations of the second relationship link instances.

[0053] In an embodiment of the present invention, by way of example, for instance, in the environment of a large-scale online education platform that has a vast number of small course files, including video courses, document materials, practice questions, 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 files and the user business, the server first obtains a second embedding vector. This second embedding vector is used to describe the network parameters when predicting the user business network branch of the small file network branch. For example, the server analyzes and learns a large amount of historical data to obtain a second embedding vector that can reflect students' learning preferences and behavioral patterns at 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 at different difficulty levels. The server obtains the link feature representations of multiple second relationship link instances. For example, there are 8000 such instances, and each instance describes the association between a student (user business) and a specific course small file. For the link feature representation of each second relationship link instance, the server performs a feature merging operation on it with the obtained second embedding vector. For example, for a certain second relationship link instance, its link feature representation may include the student's current learning progress, mastered knowledge points, the type of the 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 generally have more interest in courses with practical cases, and the current course small file in the link feature representation is exactly 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 and more realistic merged feature representation. 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 patterns of different students to similar course small files at similar learning stages, and the frequency changes of the same course small file being accessed at different time periods. After being processed by the first downsampling unit, the server obtains the association feature representations of each second relationship link instance. These association feature representations more deeply reveal the mutual influence of the small file associations in each second relationship link instance. For example, for a course small file about mathematical functions, if multiple students at the same learning stage view this file and then immediately view the relevant practice question small files, then this association feature representation will prominently display this association relationship, indicating that students have a high demand for relevant practice questions 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 item descriptions, mission guides, map details, etc.).The server obtains a second embedding vector, which contains information such as the player's gaming style (aggressive or conservative) and preferred game types (role-playing or strategy). When processing the link feature representation of the second relationship link instance (such as the player's usage of specific items in a certain level and the completion method of specific tasks), it is merged with the second embedding vector. The first downsampling unit analyzes the associated features between the player and other relevant small files (such as guides for subsequent levels and acquisition methods of similar items) in the current gaming scenario based on the merged feature representation. In this way, the server can more accurately predict the small files that the player may need, prepare and optimize in advance, and 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 and the characteristics of common diseases. When processing the link feature representation of the second relationship link instance (such as a doctor's diagnostic process for a specific patient's condition and the relevant medical materials consulted), a merging operation is performed. The first downsampling unit obtains the associated features between the doctor and other relevant small files (such as treatment plans for similar cases and the latest medical research results) when dealing with such conditions based on the merged feature representation. In this way, the server can provide more timely and comprehensive information support for doctors, improving the quality and efficiency of medical services. In summary, by obtaining the second embedding vector, merging it with the link feature representation of the second relationship link instance, and then processing it through the first downsampling unit, the server can more accurately grasp the associations between small files and the needs of user services in the scenario of improving the performance of massive small files in a distributed file system, and provide better and more efficient services for users.

[0054] In an embodiment of the present invention, according to the first weight allocation unit, a linear superposition process is performed on the associated feature representation of the second number of the second relationship link instances and the link weight coefficient to obtain a small file instance feature representation, and the implementation can be executed through the following examples.

[0055] According to the first weight allocation unit, a linear superposition process is performed on the associated feature representation of the second number of the second relationship link instances and the link weight coefficient 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, by way of example, for instance, in the environment of a large online music platform, the platform has a vast number of small music files, including songs, music albums, music reviews, etc. The server needs to efficiently process the interactions between users and these small files to provide high-quality music services. The server obtains a large number of associated feature representations of the second relationship link instances and the corresponding link weight coefficients. For example, there are 10,000 such instances here. For each second relationship link instance, its associated feature representation may include information such as the user's music preferences (such as favorite music genres, singers, eras, etc.), the listening situation of other music related to the current small music file, etc. The link weight coefficient reflects the importance of this associated feature in predicting the user's subsequent behavior. The first weight allocation unit will perform a linear superposition process on the associated feature representations of these 10,000 second relationship link instances according to these link weight coefficients. For example, for a certain user, if they often listen to other popular songs of a certain singer immediately after listening to a song of that singer, then the link weight coefficient of this associated feature representation will be relatively high. Through the linear superposition process, considering all the associated feature representations and link weight coefficients comprehensively, the server obtains a target merged feature representation. This target merged feature representation integrates a large amount of association information between users and music files, and can initially reflect the user's music listening pattern and potential needs. The server performs a feature integration operation on the obtained target merged feature representation and the previously obtained second embedding vector. The second embedding vector contains information such as the listening trends of the overall users of the music platform and the characteristics of popular music. For example, the second embedding vector may reflect the style characteristics of current popular music and the general degree of preference of users for a certain music element. 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 certain user has a high degree of attention to a specific style of music, and the second embedding vector indicates that there are new popular works of this style of music recently released, then after the integration operation, it can more accurately predict that the user may be interested in these new works. Thus, finally, a small file instance feature representation that can comprehensively and accurately reflect the user's music preferences and potential needs is obtained. For example, in another scenario, it is an online video platform. The associated feature representations of the second relationship link instances obtained by the server may include the user's viewing history (favorite movie genres, directors, actors, etc.), the review and sharing situation of a certain movie, etc. The link weight coefficient reflects the importance of these associated features. After the linear superposition process by the first weight allocation unit, a target merged feature representation is obtained, which reflects the user's viewing habits and patterns. Then, it is integrated with the second embedding vector that contains information such as popular video trends and the audience distribution of different types of movies.In this way, the server can more accurately predict new movies that the user may be interested in, related small video files of the film and television (such as actor interviews, behind-the-scenes footage), etc., and prepare these small files for the user in advance to enhance the user's movie-watching experience. Another example is an online reading platform. The associated feature representation of the second relationship link instance may cover the user's reading preferences (types of books liked, authors, themes, etc.), reading duration 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 popularity trends of various types of books and topics generally concerned by readers. The finally obtained small file instance feature representation can help the server accurately recommend relevant books, articles and other small files to the user, meeting the user's reading needs. To sum up, through the linear superposition process 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 the user and the small files in the scenario of improving the performance of a large number of small files in a distributed file system, provide more personalized and timely small file services for the user, and improve the performance of the entire system and user satisfaction.

[0058] In an embodiment of the present invention, 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 representations 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, which can be implemented through the following examples.

[0059] Performing a feature merging operation on the first embedding vector and the link feature representations of each of the first relationship link instances respectively to obtain the first merged feature representation of each of the first relationship link instances;

[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, and the associated feature representations of each of the first relationship link instances are used to describe the mutual influence situation of the user service association in the corresponding first relationship link instance;

[0061] Determining the associated feature representations of each of the first relationship link instances as the original data of the second weight allocation unit to obtain the link weight coefficients of each of the first relationship link instances;

[0062] Performing a linear superposition process on the associated feature representations of the first number of the first relationship link instances and the link weight coefficients according to the second weight allocation unit to obtain the first weight allocation feature representation;

[0063] Perform a feature integration operation on the first weight assignment feature representation and the first embedding vector to obtain a user service instance feature representation.

[0064] In an embodiment of the present invention, exemplarily, for example, in an environment of an e-commerce shopping platform, there are a large number of small commodity information files on the platform, including commodity details, user evaluations, purchase records, etc. The server needs to process a large number of interactions between users and these small files to provide a high-quality shopping experience. The server obtains a first embedding vector, which contains information about the general patterns and trends of user shopping behaviors, such as the popular commodity categories in different seasons, the consumption preferences of users of different age groups, etc. At the same time, the server also obtains the link feature representations of multiple first relationship link instances. For example, there are 5000 instances here. The link feature representation of each first relationship link instance may include the specific shopping behaviors of the user, such as the types of commodities browsed, the commodities added to the shopping cart, the keywords searched, etc. The server performs a feature merging operation on the first embedding vector and the link feature representations of each first relationship link instance respectively. For example, for a certain first relationship link instance, its link feature representation shows that the user is browsing summer clothing, while the first embedding vector indicates that the current popular style of summer clothing is minimalist. Through the merging operation, a richer first merged feature representation is obtained, which can more comprehensively reflect the potential shopping needs of the user. The server loads the first merged feature representations of each first relationship link instance into the second downsampling unit respectively. The second downsampling unit will process and analyze these first merged feature representations. It will consider multiple factors, such as the shopping behaviors of similar user groups within the same time period, the sales situations of the same commodity in different regions, etc. After being processed by the second downsampling unit, the server obtains the associated feature representations of each first relationship link instance. These associated feature representations more deeply describe the mutual influence situation of the user business associations in the corresponding first relationship link instances. For example, for a first relationship link instance where a user browses summer clothing, if other users with similar shopping behaviors view related accessory commodities immediately 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 assignment unit. The second weight assignment unit will assign a link weight coefficient to each first relationship link instance according to these associated feature representations. This coefficient reflects the importance of this link in predicting the subsequent shopping behaviors of the user. For example, if a certain associated feature representation shows that the user has a greater browsing depth and stronger purchase intention for a certain type of commodity, then the corresponding link weight coefficient will be higher, indicating that this link is more important for predicting the subsequent shopping behaviors of the user. The server performs a linear superposition process on the associated feature representations and link weight coefficients of these 5000 first relationship link instances according to the second weight assignment unit to obtain a first weight assignment feature representation. Then, a feature integration operation is performed on the first weight assignment feature representation and the first embedding vector.Through integration, the general shopping behavior patterns of users and the specific characteristics of the shopping link are synthesized, so as to obtain a feature representation of the user business instance that can accurately reflect the shopping tendencies and needs of users. For example, the feature representation of the user business instance may show that after a user browses a certain electronic product, they are more likely to pay attention to its related peripheral accessories. The server can then prepare relevant small files in advance, such as the detailed introduction of the accessories and the preferential information, to improve the efficiency and satisfaction of users' shopping. For example, in another scenario, it is an online travel reservation platform. The first embedding vector contains information such as popular tourist destinations in different seasons and the travel preferences of users. The link feature representation of the first relationship link instance may include the tourist locations searched by the user, the hotel details viewed, the ticket reservation time, etc. Through steps such as feature merging, processing by the second downsampling unit, processing by the second weight assignment unit, and linear superposition and feature integration, the server can obtain the feature representation of the user business instance. This feature representation may indicate that after a user reserves a hotel in a certain city, they are likely to query small files such as local tourist attraction tickets or transportation guides, and the server can make preparations in advance to optimize the user experience. Another example is an online knowledge payment platform. The first embedding vector reflects the popularity of various knowledge courses and the learning preference trends of users. The link feature representation of the first relationship link instance covers the course topics browsed by the user, the course duration viewed, the content of the questions asked, etc. Through a series of processes, the finally obtained feature representation of the user business instance can help the server predict relevant small files that the user may be interested in next, such as advanced courses in the same field and lectures by relevant experts, and prepare these small files in advance to improve the convenience of users' access to knowledge. In summary, through the above series of processing steps, the server can accurately grasp the business needs of users in the scenario of improving the performance of a large number of small files in a distributed file system, and provide more considerate and efficient services for users.

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

[0066] Extract the feature representation of the target user business instance and the feature representations of each adjacent instance directly related to the target user business instance from the first combined feature representation of the first relationship link. The first relationship link is any relationship link among the first number of first relationship link instances, and the target user business instance is any user business instance in the first relationship link;

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

[0068] Perform a linear superposition process on the feature representations corresponding to each of the adjacent instances according to the weight coefficient instances of the respective adjacent instances to obtain the associated feature representation of the first relationship link.

[0069] In an embodiment of the present invention, by way of example, for instance, in a large online news platform, there are a vast number of news small files on the platform, including various types of news reports, comments, special topics, etc. The server needs to process a large number of interactions between users and these news small files to provide personalized news recommendation services. The server loads the first combined feature representations of multiple first relationship link instances into the second downsampling unit respectively. For each first relationship link instance, such as the link of user A browsing news. From the first combined feature representation of this first relationship link, the feature representation of the target user service instance is extracted. For example, the target user service instance is a news report about the development of technology browsed by user A. At the same time, the feature representations of each adjacent instance directly related to this target user service instance are also extracted, such as other news recommended on the same page as this technology news, or relevant news under the same theme. The server performs a multiplication operation on the feature representation of the target user service instance (technology news) and the feature representations of each adjacent instance (such as relevant recommended news) respectively. For example, the feature representation of the target user service instance contains information such as the browsing duration of user A for the technology news, whether it is shared, and the comment content, and the feature representation of the adjacent instance contains the type, popularity, release time, etc. of the news. Through the multiplication operation, the weight coefficient instances of each adjacent instance in the first relationship link are obtained. If user A stays on the technology news for a long time and a certain adjacent fintech news has a high correlation with this technology news, then the weight coefficient instance obtained by their multiplication will be larger, indicating that the user may have a high interest in this fintech news. The server performs a linear superposition process on the feature representations of the corresponding adjacent instances according to the weight coefficient instances of each adjacent instance. For example, there are three adjacent news, namely fintech news, technology enterprise dynamics news, and technology policy interpretation news, and their weight coefficient instances are 0.8, 0.6, and 0.4 respectively. The corresponding feature representations contain information such as the content summary, author, source, etc. of the news. Through the linear superposition process, the feature representations of these three news are weighted and summed according to the weight coefficients. The result obtained is the associated feature representation of the first relationship link, which comprehensively reflects the association degree and potential interest tendency between user A's browsing of technology news and these adjacent news. For example, in another scenario, it is an online learning platform. For the first relationship link instance of user B watching a certain math course video. The feature representation of the target user service instance (this math course video) and the feature representations of adjacent instances related thereto are extracted from its first combined feature representation, such as the exercise questions in the same chapter, the explanation videos of relevant knowledge points, etc. Through calculating the weight coefficient instances and the linear superposition process, the associated feature representation of the first relationship link is obtained.If user B repeatedly watches the math course video and the instance of the weight coefficient of the exercise questions is relatively high, it indicates that the user may need to practice and consolidate immediately; if the instance of the weight coefficient of the relevant knowledge point explanation video is relatively high, it indicates that the user may have a need for extended knowledge. For another example, on an online social platform. For the first relationship link instance of a certain status posted by user C. Extract the feature representation of the target user's business instance (this status), as well as the feature representations of adjacent instances, such as friends' comments, likes, etc. After calculation and processing, the obtained associated feature representation can reflect the influence of this status of user C in the social network and the tightness of relevant interactions, thus 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 potential needs and interest tendencies of users when facing a large number of small files and complex user business relationships, provide more accurate and personalized services for users, and improve the performance and user experience of the distributed file system.

[0070] In an embodiment of the present invention, the following implementation manners are further provided.

[0071] Calculate the first mean absolute error between the feature representation of the user business instance and the second embedding vector;

[0072] Optimize the first embedding vector and the second embedding vector according to the first mean absolute error.

[0073] In an embodiment of the present invention, by way of example, for instance, in a large online photo sharing platform, the server needs to process a vast number of small photo files as well as operations such as users' browsing, collecting, and commenting on these photos. First, the server obtains the user business instance feature representation through a series of previous processing steps. This feature representation comprehensively reflects the user's photo operation behaviors and preferences on the platform. At the same time, the server also has a second embedding vector, which contains information such as the popularity trends of overall photo types on the platform and the general preferences of different user groups. 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 indicates that user A is mainly interested in landscape photos and tends to browse high-definition and brightly colored landscape photos. While the second embedding vector reflects that portrait photos are more popular on the current platform and there is a general preference for vintage tones. The server calculates the absolute error value between the two vectors by comparing the differences in dimensions such as photo type and color preference. Then, multiple such error values are averaged to obtain the first mean absolute error. Based on 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 indicates that the user's personal preferences deviate significantly from the overall trends of the platform. The server will adjust the first embedding vector to more accurately reflect the unique photo preferences of user A, such as increasing the weight of features related to landscape photos. At the same time, the server will also optimize the second embedding vector according to this error to more comprehensively reflect the diverse preferences of users on the platform, such as appropriately increasing the weight of landscape photos in the overall popularity trends. Through such optimization, when user A accesses the platform next time, the server can more accurately recommend small landscape photo files that match their personal preferences. At the same time, it can also make the overall recommendation strategy of the platform more in line with the actual needs of users, improving the user experience and the service quality of the platform, thereby enhancing the performance of the distributed file system when processing a vast number of small photo files. Another example is in the scenario of an online document storage platform. The user business instance feature representation shows that user B frequently accesses technical documents and is more concerned about the latest released documents. While the second embedding vector reflects that most users on the platform tend to consult classic industry reports. The server calculates the first mean absolute error between the two and optimizes the embedding vectors accordingly. It will enhance the representation of technical documents and the latest release features in the first embedding vector, and at the same time adjust the second embedding vector to more balancedly 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 and also optimize the platform's management and recommendation of various documents, enhancing the performance of the entire system.

[0074] In an embodiment of the present invention, the following implementation manners are also provided.

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

[0076] Optimize the second embedding vector and the first embedding vector according to the second mean absolute error.

[0077] In an embodiment of the present invention, by way of example, for instance, in a large online video platform, the server needs to process a vast number of small video files, including various types of movies, TV dramas, short videos, etc., as well as user operations such as playing, pausing, favoriting, and commenting on these videos. First, the server obtains the small file instance feature representation through a previous processing flow, which reflects the association and potential needs between the user and a specific small video file. At the same time, the server also has a first embedding vector, which contains information such as the overall trend of video content on the platform and the general preferences of the user group. 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 been frequently watching science fiction movies recently and has shown a significant 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 movies. By comparing the differences between these two vectors in dimensions such as movie type, video quality preference, and actor attention, the server calculates the absolute error value for each dimension and then averages these error values to obtain the second mean absolute error. Based on 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 indicates that there are significant differences between user A's specific preferences and the overall trend of the platform. The server will adjust the first embedding vector to more accurately reflect user A's preference for science fiction movies and specific video quality, such as increasing the weights of relevant features such as the science fiction movie type and high frame rate special effects. At the same time, the server will also optimize the second embedding vector based on this error to more comprehensively cover the diverse preferences of users, such as appropriately increasing the weight of science fiction movies in the overall popularity trend to better balance the attention of different types of movies. Through such optimization, when user A accesses the platform next time, the server can more accurately recommend small science fiction movie files that match their preferences, and at the same time make the platform's recommendation strategy more in line with the actual needs of the majority of users, improving the user experience and the service quality of the platform, thereby effectively enhancing the performance of the distributed file system when processing a vast number of small video files. Another example is in the scenario of an online music platform. The small file instance feature representation shows that user B always listens to classical music, especially likes piano concertos, and prefers lossless audio versions. The first embedding vector reflects that the listening volume of popular music is higher on the platform and users generally pay more attention to the lyrics of songs. The server calculates the second mean absolute error between the two and optimizes accordingly. It will enhance the representation of features such as classical music, piano concertos, and lossless audio in the first embedding vector, and at the same time adjust 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 their favorite classical music small files and 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 service network branch includes a third number of federated learning units, a boundary condition learning unit, and an average pooling unit; determining one of the small file instance feature representations or the first embedding vectors and the link feature representations 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, and the implementation can be executed through the following examples.

[0079] Loading the link feature representations of the first relationship link instances and the third number of federated learning vectors into the third number of federated learning units to obtain the third number of preference vectors of the first relationship link instances, each of the federated learning units outputs one preference vector, and each of the federated learning vectors is used to characterize the preference degree of the corresponding federated learning unit for the small file instance;

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

[0081] Loading the second combined feature representations of the first number of the first relationship link instances into the average pooling unit to obtain the user service instance feature representation.

[0082] In an embodiment of the present invention, by way of example, for instance, in a large online game platform, there are a vast number of small game-related files on the platform, including game guides, character introductions, game patches, etc. The server needs to handle a large number of interaction operations between players and these small files. The server obtains the link feature representations of multiple first relationship link instances. For example, there are 2000 instances here. Each link feature representation contains information such as the player's game behavior, game progress, and selected game character. At the same time, the server also has a third quantity (for example, 5) of joint learning vectors. The link feature representation of each first relationship link instance and these 5 joint learning vectors are loaded into the corresponding 5 joint learning units. For example, for a certain 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 vectors. The preference vector output by each joint learning unit represents the preference degree of the unit for small file instances (such as equipment guides for a specific level, introduction to the weaknesses of monsters in this area, etc.). For example, the first joint learning unit has a higher preference degree for equipment guides and outputs a larger preference vector value; the second joint learning unit has a lower preference degree for the introduction to the weaknesses of monsters and outputs a smaller preference vector value. The server loads the 5 preference vectors, 5 joint learning vectors, and small file instance feature representations (such as the features of the current popular game) of each first relationship link instance into the boundary condition learning unit. The boundary condition learning unit will comprehensively analyze and process this information. For example, for a certain first relationship link instance, if its preference vectors show a high demand for equipment guides and skill upgrade guides, while the joint learning vectors and small file instance feature representations indicate that there are important updates in these two aspects in the current game, then the boundary condition learning unit will generate a second combined feature representation that can reflect this comprehensive information. This second combined feature representation more comprehensively reflects the potential needs and importance degree of players for relevant small files in the current game state. The server loads the second combined feature representations of these 2000 first relationship link instances into the average pooling unit. The average pooling unit will perform an average process on these feature representations. For example, it will calculate the average value of these 2000 second combined feature representations in each dimension, so as to obtain a user service instance feature representation that can represent the general needs and behavior patterns of the overall player group in the current game environment. Through this feature representation, the server can better predict the small files that players may need, such as preparing in advance the introduction of new gameplay of popular games, notifications of upcoming game activities, etc., 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 contains the student's learning courses, learning progress, homework completion situation, etc.The combined learning vector may represent the attention to different types of learning materials (such as knowledge point explanation videos, exercise questions, case analyses). After being processed by the combined learning unit and the boundary condition learning unit, the second combined feature representation of each student is obtained, and then through the average pooling unit, a user service instance feature representation that can reflect the learning needs of the entire student group is obtained. The server can, based on this feature representation, cache in advance small files such as review materials for popular courses and the latest interpretations of the exam syllabus to improve system performance. For another 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 content, etc. The combined learning vector can represent the preference degree for different product attributes (such as brand, price, material). Through a series of processes, the finally obtained user service instance feature representation can help the server prepare in advance small files such as promotional information for popular products and recommended similar products, speed up the information acquisition speed when users are shopping, and optimize the shopping experience. In summary, through the collaborative work of the combined learning unit, the boundary condition learning unit, and the average pooling unit, the server can more accurately grasp the user's business needs in the scenario of improving the performance of massive small files under a distributed file system, and achieve more efficient small file management and service provision.

[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 combined learning vectors into the third number of combined learning units to obtain the third number of preference vectors of each of the first relationship link instances includes:

[0084] Extracting the feature representation of the target user service instance and the feature representations of each adjacent instance directly related to the target small file instance from the link feature representation of the second relationship link, where the second relationship link is any one of 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 a feature integration operation on the feature representation of the target user service instance and the third number of the combined learning vectors respectively to obtain the third number of first integration vectors;

[0086] Performing a multiplication operation on the third number of the first integration vectors and the feature representations of each of the adjacent instances respectively to obtain the weight coefficient instances of each of the adjacent instances in the second relationship link;

[0087] Performing a linear superposition process on the feature representations of the corresponding adjacent instances according to the weight coefficient instances of each of the adjacent instances to obtain the third number of preference vectors of the second relationship link.

[0088] In an embodiment of the present invention, by way of example, for instance, in a large online video platform, the server needs to process a vast number of small video-related files, including movies, TV series, trailers, movie reviews, etc., as well as user interaction operations with these small files. The server obtains a large number of link feature representations of the first relationship link instances. For example, the first quantity is 5000. For any one of the second relationship links (such as the movie-watching link of user A), the feature representation of the target user service instance is extracted from its link feature representation (for example, a science fiction movie that user A is currently watching), as well as the feature representations of each adjacent instance directly related to the target small file instance (such as other works by the same director, other movies by the same lead actor, popular movies of the same genre, etc.). The server performs a feature integration operation on the feature representation of the target user service instance with three (for example) joint learning vectors. For example, the feature representation of the target user service instance may include information such as the type, duration, and user viewing progress of the movie. The joint learning vectors may respectively represent the attention to plot complexity, visual effects, and acting skills of the actors. Through the feature integration operation, three first integration vectors are obtained. For example, the first joint learning vector focuses on plot complexity. After being integrated with the feature representation of the target user service instance, the resulting first integration vector reflects user A's comprehensive evaluation of the plot complexity of the currently watched movie. The server performs a multiplication operation on these three first integration vectors with the feature representations of each adjacent instance respectively. The feature representation of the adjacent instance may include evaluations of aspects such as the plot complexity, visual effects, and acting skills of the adjacent movie. Through the multiplication operation, the weight coefficient instances of each adjacent instance in the second relationship link are obtained. For example, if the first integration vector indicates that user A has a high evaluation of the plot complexity 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 large, indicating that user A may have a high interest in this adjacent movie. The server performs a linear superposition process on the feature representations of the corresponding adjacent instances according to the weight coefficient instances of each adjacent instance. For example, there are five adjacent movies, namely movie 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 movie's synopsis, rating, and reviews. Through the linear superposition process, the feature representations of these five adjacent movies are weighted and summed according to the weight coefficients. Finally, three preference vectors of the second relationship link are obtained, which respectively reflect user A's preference degrees for adjacent movies in terms of plot complexity, visual effects, and acting skills. For example, in another scenario, it is an online music platform. For the song-listening link of user B, the feature representation of the target user service instance (a popular song being listened to) is extracted, as well as the feature representations of adjacent instances directly related to this song (other songs by the same singer, popular songs of similar styles, etc.).By operating on three collaborative learning vectors (representing preferences for melody, lyrics, and arrangement respectively), weight coefficient instances are calculated and linearly superimposed to obtain three preference vectors reflecting User B's preferences for adjacent songs in terms of melody, lyrics, and arrangement. Based on these preference vectors, the server can pre-cache small song files that User B may be interested in, improving the smoothness of music playback and the user experience. Another example is in the scenario of an online reading platform. For User C's reading path, the feature representations of the target user's business instance (a novel being read) and adjacent instances (other works by the same author, popular novels of the same type, etc.) are extracted. Corresponding operations are performed with three collaborative learning vectors (representing attention to plot, writing style, and theme respectively) to 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 relevant novels in advance to meet the user's reading needs and improve system performance. In summary, through the above detailed processing steps, the server can accurately mine the latent interests and preferences of users in the face of a large number of 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 in processing a large number of 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 collaborative learning vectors, and the small file instance feature representation are loaded into the boundary condition learning unit to obtain the second combined feature representation of each of the first relationship link instances, which can be implemented through the following examples.

[0090] For each of the first relationship link instances, the third number of the collaborative learning vectors are respectively multiplied with the small file instance feature representation to obtain the weight coefficients of each of the preference vectors in each of the first relationship link instances;

[0091] For each of the first relationship link instances, the corresponding third number of preference vectors are linearly superimposed according to the weight coefficients of the third number of the preference vectors to obtain the second combined feature representation of each of the first relationship link instances.

[0092] In an embodiment of the present invention, by way of example, for instance, in a large online e-commerce platform, the server needs to process a vast number of small product-related files, including product detail pages, user reviews, product recommendations, etc., as well as user interaction operations with these small files. The server obtains a plurality of first relationship link instances. For each first relationship link instance (such as the shopping link of user A), the server performs a multiplication operation on the third quantity (for example, 3) of joint learning vectors with the feature representation of the small file instance (such as the features of currently popular products). For example, the joint learning vectors respectively represent the degree of attention to price sensitivity, brand preference, and functional requirements for products, and the feature representation of the small file instance contains information about the price range, brand popularity, functional features, etc. of the popular products. Through the multiplication operation, the weight coefficients of each preference vector are obtained. For example, if user A is usually more sensitive to price and the current popular product has a significant price advantage, then the weight coefficient obtained by multiplying the joint learning vector corresponding to price sensitivity with the feature representation of the small file instance will be larger. For each first relationship link instance, the server performs a linear superposition process on the corresponding preference vectors according to the calculated weight coefficients of the three preference vectors. For example, for the shopping link of user A, the three preference vectors are respectively the preference for products with price discounts, the preference for products of well-known brands, and the preference for products with specific functions, and their corresponding weight coefficients are 0.6, 0.3, and 0.1 respectively. Through the linear superposition process, these three preference vectors are weighted and summed according to the weight coefficients. Finally, the second combined feature representation of user A, this first relationship link instance, is obtained. This second combined feature representation comprehensively considers various preferences of user A and the features of the 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 reservation platform. For the travel planning link of user B, the joint learning vectors can respectively represent the attention to destination security, popularity of tourist attractions, and accommodation price. The feature representation of the small file instance includes the situations of popular tourist destinations in these aspects. By calculating the weight coefficients and performing the linear superposition process, the second combined feature representation of user B is obtained, reflecting their comprehensive preferences and needs for travel products. The server can, based on this feature representation, prepare in advance small files such as travel route recommendations and preferential activity notifications that user B may be interested in, improving the user's reservation experience and the service efficiency of the platform. Another example is in the scenario of an online financial service platform. For the investment and financial management link of user C, the joint learning vectors can respectively represent the attention to investment risk tolerance, expected return, and investment term. The feature representation of the small file instance covers the characteristics of various financial products in these aspects. After corresponding processing, the second combined feature representation of user C is obtained, helping the server more accurately push small files such as introductions of suitable financial products and market dynamic analyses to user C, meeting the user's financial management needs, and at the same time improving the performance and response speed of the system.In summary, by performing the above processing on the joint learning vector, the small file instance feature representation, and the preference vector, the server can deeply explore the user's needs when faced with a large number of small files and complex user service relationships, provide more accurate and personalized services for users, effectively improve the performance of the distributed file system in processing a large number of small files, and enhance the user's satisfaction and dependence on the platform.

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

[0094] Extract the feature representation of the target small file instance and the feature representations of each adjacent instance directly related to the target small file instance from the link feature representation of the third relationship link, where the third relationship link is any relationship link among the second quantity of second relationship link instances, and the target small file instance is any small file instance in the third relationship link;

[0095] Perform multiplication operations on the feature representation of the target small file instance and the feature representations of the adjacent instances respectively to obtain the weight coefficient instances of the adjacent instances in the third relationship link;

[0096] Perform linear superposition processing on the feature representations of the adjacent instances according to the weight coefficient instances of the adjacent instances to obtain the associated feature representation of the third relationship link.

[0097] In an embodiment of the present invention, exemplarily, for example, in a large online course platform, the server needs to process a large number of small course-related files, including course videos, courseware, assignments, etc., as well as user interactions with these small files. The server obtains a large number of link feature representations of second relationship link instances. For example, the second quantity is 8,000. For any one of the third relationship links (such as the link of user A learning a certain course), extract the feature representation of the target small file instance from its link feature representation (for example, it is the course video of a certain chapter that user A is learning), and the feature representations of each adjacent instance directly related to the target small file instance (such as the previous chapter video, the subsequent chapter video, related supplementary courseware, etc. of the same course). The server respectively performs a multiplication operation on the feature representation of the target small file instance and the feature representations of each adjacent instance. For example, the feature representation of the target small file instance may 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 may include evaluations in aspects such as the importance, relevance, and difficulty of the adjacent chapter video. Through the multiplication operation, obtain the weight coefficient instances of each adjacent instance in the third relationship link. 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 certain adjacent chapter video has a high correlation with this key chapter, then the weight coefficient instance obtained by their multiplication will be larger, indicating that user A may have a higher degree of attention to this adjacent chapter video. The server performs a linear superposition process on the feature representations of the corresponding adjacent instances according to the weight coefficient instances of each adjacent instance. For example, there are 5 adjacent instances, namely the previous chapter video, the subsequent chapter video, supplementary courseware A, supplementary courseware B, and related assignments, and their corresponding weight coefficient instances are 0.7, 0.5, 0.3, 0.2, and 0.1 respectively. The feature representations of the adjacent instances include information such as the main content of the chapter, the knowledge points of the courseware, and the difficulty of the assignment. Through the linear superposition process, perform a weighted sum of the feature representations of these 5 adjacent instances according to the weight coefficients. Finally, obtain the associated feature representation of the third relationship link, which reflects the degree of association and potential needs between user A and these adjacent instances when learning the current course video. For example, if the result of the linear superposition process shows a high degree of association with the subsequent chapter video and related assignments, 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 the subsequent chapter and answer analysis of the assignments, to improve the user's learning efficiency and experience. For example, in another scenario, it is an online knowledge Q&A platform. For the answering link (third relationship link) of a certain question, extract the feature representation of the target small file instance (the current best answer), and the feature representations of each adjacent instance directly related to this answer (such as answers to similar questions, related extended discussions, expert comments, etc.). Through the above calculation and processing steps, obtain the associated feature representation of this relationship link.Based on this associated feature representation, the server can recommend more relevant and valuable content to users, enhancing the interactivity of the platform and the effect of knowledge dissemination. Another example is in the scenario of an online image library platform. For the user's browsing link of a certain image (the third relationship link), extract the feature representation of the target small file instance (the current image) and the feature representations of each adjacent instance directly related to this image (such as other images of the same theme, images of similar styles, relevant image captions, etc.). After corresponding processing, an associated feature representation is obtained. Based on this, the server can display a picture set that better matches the user's interests for the user, 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 in a distributed file system, provide more targeted and practical services for users, and significantly improve the system performance and user satisfaction.

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

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

[0100] Optimize the parameters of the basic graph neural network model according to the target error parameter to obtain the target graph neural network model.

[0101] In an embodiment of the present invention, by way of example, for instance, in a large online news recommendation platform, the server needs to process a vast number of news small files, including news articles of various types and topics, as well as user interactions with these news items, such as browsing, liking, commenting, etc. The server has obtained the feature representations of small file instances and user business instances through previous processing steps. The feature representation of a small file instance may include features such as the topic, keywords, popularity, etc. of the news article, while the feature representation of a user business instance reflects the user's interest preferences, reading history, behavior patterns, etc. The server begins to calculate the deviation between the feature representation of the small file instance and the feature representation of the user business instance. For example, the feature representation of the small file instance shows that the currently popular news is about a major breakthrough in the technology field, while the feature representation of the user business instance indicates that the user generally pays more attention to news in the entertainment and sports aspects. By comparing the differences between these two feature representations in dimensions such as topic and keywords, the server calculates the deviation between them. This deviation may be manifested in multiple aspects, such as the degree of mismatch of news topics and the relatively low coincidence degree of keywords, etc. The server combines these deviations to obtain a target error parameter, which quantitatively describes the degree of mismatch between the small file and the user business. After obtaining the target error parameter, the server optimizes the parameters of the basic graph neural network model according to this error. For example, if the target error parameter is large, it indicates that the current prediction result of the model is quite different from the actual situation. The server will adjust parameters such as weights and biases in the model so that the model can more accurately learn the relationship between the small file and the user business. For example, if a certain weight parameter in the model is too high, resulting in overemphasis on certain news features, the server will reduce this weight to balance the influence of different features. Another example is that if a certain bias parameter is set unreasonably, causing the model to misunderstand certain types of user business, the server will adjust this bias to make the output of the model more in line with the actual needs. By continuously optimizing the parameters according to the target error parameter, the model can gradually capture the association between the small file and the user business more accurately. For example, after multiple optimizations, when a new technology news appears, the model can accurately judge the degree of interest of the user in this 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 feature representation of the small file instance includes information such as the topic, format, author, etc. of the document, and the feature representation of the user business instance covers the user's work field, commonly used document types, search history, etc. The server calculates the deviation between them and obtains the target error parameter. Then, according to this error parameter, the model parameters are adjusted 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 for and browses marketing plan documents, but the model previously misrecommended technical documents to the user, by optimizing the model parameters, such incorrect recommendations can be reduced, and document recommendations more in line with the user's work needs can be provided to the user. Another example is in the scenario of an online music recommendation platform. The small file instance feature representation includes the style of the song, the singer, the release time, etc., and the user business instance feature representation reflects the user's music preferences, listening history, favorite songs, etc. 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 suit the user's taste, improve the accuracy and satisfaction of music recommendations, and thus enhance the performance of the distributed file system when processing a large number of music small 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 according to this parameter, the server can continuously improve the performance of the model, better meet the user's needs in the scenario of a large number of small files, and improve the overall efficiency and user experience of the system.

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

[0103] In an embodiment of the present invention, by way of example, for instance, in a large online picture library platform, the server processes a vast number of small picture files, covering various themes and styles, while serving numerous user operations such as browsing, downloading, and collecting. When calculating the deviation between the feature representation of the small file instance and the feature representation of the user service instance to obtain the target error parameter, the focus error parameter therein plays an important role. For example, the feature representation of the small file instance may include features such as the theme of the picture (such as scenery, people, animals, etc.), shooting techniques (such as close-up, panorama, backlight, etc.), and color distribution. The feature representation of the user service instance, on the other hand, reflects the user's browsing history (the picture themes frequently viewed), collection behavior (preferred shooting styles), search keywords, etc. When the server calculates the focus error parameter, it will pay particular attention to those focus aspects that the user is currently most concerned about or frequently operates on. For example, during a certain period, the user frequently searches for and browses pictures of a specific theme (such as seascapes), and shows a distinct preference for seascapes with a specific color style (such as blue tone). However, among the small picture files recommended by the model, the proportion of pictures that meet these focus features is relatively low or not precise enough. The server determines the focus error parameter by comparing the difference between the user's focus requirements and the actual recommended results. If the proportion of the blue tone in the recommended seascapes is far lower than the user's expectation, or the recommended seascapes do not match the user's preferences in terms of key focus features such as shooting angle and clarity, a relatively large focus error will occur. By accurately calculating and analyzing the focus error parameter, the server can more clearly understand the deficiencies of the model in meeting the user's specific focus requirements, and thus targetedly optimize and improve the model. For example, the server can adjust the weights related to the features of the seascape pictures in the model, increasing the weights of focus features such as the blue tone and specific shooting angles, to improve the accuracy and pertinence of subsequent recommendations, enhance the user experience, and optimize the performance of the distributed file system when processing a vast number of small picture files. Another example is in an online course platform, where the focus error parameter may be reflected in the high attention of users to a certain type of popular course (such as the Python course in programming languages) during a specific period, and the key requirements for specific content of the course (such as the data analysis part). By calculating the focus error parameter in this regard, the server can accurately optimize the course recommendations and better meet the learning focus requirements of users at a specific stage.

[0104] In an embodiment of the present invention, to obtain the first quantity of first relationship link instances and the second quantity of second relationship link instances, the following example can be executed for implementation.

[0105] Obtain multi - relationship network data, where the multi - relationship network data includes the first quantity of the first relationship link instances and the second quantity of the second relationship link instances, and the multi - relationship network data is used to describe the multi - level interaction framework between the user service instance and the small file instance.

[0106] In an embodiment of the present invention, by way of example, for instance, in a large-scale online office software platform, the server needs to process a vast amount of small files, such as documents, spreadsheets, slides, etc., as well as various interaction operations between users and these small files. The server obtains multi-relational network data, which includes a first number of first relational link instances and a second number of second relational link instances. These data form a complex and comprehensive network for describing the multi-level interaction framework between user business instances and small file instances. For example, the server obtains 5000 first relational link instances and 8000 second relational link instances. In the first relational link instances, the following situations may be included: User A opens a project planning document, spends a long time reading and editing it, saves it multiple times during the period and refers to relevant template files. This link instance describes the interaction details between User A and specific small files (planning document and template files) in a specific business scenario (project planning), including the time, frequency, order of operations, etc. The second relational link instance may be like this: A popular financial statement 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 operation and usage patterns of multiple users around the same small file. Through these multi-relational network data, the server can comprehensively understand the interaction situations of users with various small files in different business contexts. For example, in another scenario, it is an online design platform. The first relational link instance obtained by the server may be: Designer D opens a design material file of a specific style and then performs a series of creations based on it, including operations such as color adjustment and element combination. The second relational link instance may be: A newly released high-definition picture material small file is quickly noticed and used by many designers within a day, and each designer applies it in different ways and fields. These relational link instances together constitute a rich multi-relational network, reflecting the complex and diverse interaction relationships between user business (design work) and small file instances (material files). Another example is in the scenario of an online education platform. The first relational link instance may be: Student E watches a video small file of a specific course, takes detailed notes, and reviews it multiple times after class. The second relational link instance may be: The summary small file of the key knowledge points of a certain chapter is intensively 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 learning behaviors of users and the demand patterns for small files, so as to better optimize the storage, retrieval, and recommendation of files, improve system performance, and provide more efficient and convenient services for users.

[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 deeply analyzing the interaction relationship between user services and small files, which helps the server make more accurate and effective decisions and optimizations in the work of improving the performance of massive small files under the distributed file system.

[0108] An embodiment of the present invention provides a computer device 100. The computer device 100 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 foregoing method for improving the performance of massive small files under the distributed file system. As Figure 2 shown, Figure 2 is a structural block diagram of the computer device 100 provided by 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 elements of the memory 111, the processor 112, and the communication unit 113 are electrically connected to each other directly or indirectly. For example, these elements can be electrically connected to each other through one or more communication buses or signal lines.

[0109] For illustrative purposes, the foregoing description has been made with reference to specific embodiments. However, the above illustrative discussion is not intended to be exhaustive or to limit the disclosure to the precise forms disclosed. Numerous modifications and variations are possible in light of the above teachings. The embodiments are chosen and described in order to best illustrate the principles of the disclosure and its practical applications, thereby enabling those skilled in the art to best utilize the disclosure and to utilize various embodiments with different modifications to suit the particular applications contemplated.

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; Returning the target small file from the cache to the user service through the private client; 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.

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 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.

4. The method according to claim 3, 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.

5. The method according to claim 4, 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.

6. The method according to claim 4, 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.

7. The method according to claim 3, 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.

8. The method according to claim 3, 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.

9. 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 8.

Images