Federated learning task execution method and computing device

Abstract

A federated learning task execution method and a computing device. The method and the computing device relate to a plurality of participants. The method is executed by a first participant among the plurality of participants. The method comprises: by running a node program of a federated learning platform, acquiring a target application program corresponding to a machine learning algorithm needing to be used by a federated learning task, wherein the target application program is from a preset algorithm repository, programs in the algorithm repository are all obtained by development on the basis of a consistent software development kit (SDK), and the SDK corresponds to the federated learning platform; and loading the target application program in the node program, and jointly executing the federated learning task with the remaining participants among the plurality of participants by means of the target application program.

Description

Methods and computing devices for performing federated learning tasks

[0001] This application claims priority to Chinese patent application filed on October 25, 2024, with application number 202411508311.9 and entitled "Method and Computing Device for Performing Federated Learning Tasks", the entire contents of which are incorporated herein by reference. Technical Field

[0002] The embodiments in this specification belong to the field of computer technology, and in particular relate to a method and computing device for executing a federated learning task. Background Technology

[0003] Federated learning fully leverages the data and computing power of participating parties, enabling multiple parties to collaborate in building more robust and effective business forecasting models without sharing training samples. In an environment of increasingly stringent data regulations, federated learning can address key issues such as data ownership, data privacy, data access rights, and access to heterogeneous data. Summary of the Invention

[0004] The purpose of this invention is to provide a method and computing device for performing federated learning tasks.

[0005] Firstly, a method for executing a federated learning task is provided. This method involves multiple participants and is executed by a first participant among them. The method includes: obtaining a target application corresponding to the machine learning algorithm required for the federated learning task by running a node program of a federated learning platform. The target application comes from a pre-set algorithm repository, where all programs are developed based on a consistent software development kit (SDK) corresponding to the federated learning platform; loading the target application into the node program; and jointly executing the federated learning task with the remaining participants through the target application.

[0006] Secondly, a computing device is provided, the computing device corresponding to a first participant among multiple participants, the computing device comprising: a program acquisition unit configured to acquire, by running a node program of a federated learning platform, a target application corresponding to a machine learning algorithm required for a federated learning task to be executed, the target application being from a pre-set algorithm repository, the programs in the algorithm repository being developed based on a consistent software development kit (SDK), the SDK being corresponding to the federated learning platform; and a program scheduling unit configured to load the target application in the node program, and jointly execute the federated learning task with the other participants among the multiple participants through the target application.

[0007] Thirdly, a computer-readable storage medium is provided having a computer program stored thereon, wherein when the computer program is executed in a computing device, the computing device performs the method described in the first aspect.

[0008] In the technical solution provided in the embodiments of this specification, for the first participant among multiple participants in executing a federated learning task, after determining the machine learning algorithm required for the task, the first participant can obtain the target application corresponding to the machine learning algorithm from a preset algorithm repository by running a node program of the federated learning platform. The target application is then loaded into the node program, and the federated learning task is jointly executed with the other participants through this target application. In this way, the application corresponding to the machine learning algorithm does not need to be directly integrated into the client or server of the federated learning platform. Relevant participants can load and use the application corresponding to the relevant machine learning algorithm as needed, which better meets the personalized needs of users for the machine learning algorithm used in the federated learning task to be executed or the business prediction model they expect to obtain, resulting in a better user experience. Attached Figure Description

[0009] To more clearly illustrate the technical solutions of the embodiments in this specification, the drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0010] Figure 1 is a schematic diagram of an implementation architecture of federated learning provided in the embodiments of this specification;

[0011] Figure 2 is a flowchart of a method for executing a federated learning task provided in an embodiment of this specification;

[0012] Figure 3 is a schematic diagram of the structure of a computing device provided in an embodiment of this specification. Detailed Implementation

[0013] To enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this specification, and not all embodiments. Based on the embodiments in this specification, all other embodiments obtained by those skilled in the art without creative effort should fall within the scope of protection of this specification.

[0014] Federated learning, also known as joint learning, enables machine learning to be performed jointly by multiple business parties possessing training samples without the need to exchange these samples. A key characteristic of federated learning is the participation of multiple business parties in a single task. Typically, a federated learning task involves two or more business parties, and in some cases, collaborating parties may also participate. The business data held by each party can be used as training samples for federated learning. In essence, federated learning utilizes the business data held by multiple business parties to jointly train a business prediction model, while adhering to requirements such as user privacy protection and data security.

[0015] For example, suppose there are two different business parties, A and B, each holding different business data. For instance, party A possesses user characteristic data for one batch of users, while party B possesses user characteristic data for another batch. Due to user privacy protection considerations, neither party can send their respective user characteristic data to other devices. If each business party uses its own business data to train its business prediction model, it may fail to obtain a high-quality prediction model due to insufficient or incomplete sample data. However, through federated learning, data from multiple business parties can be used to collaboratively train the model while protecting privacy and data security, allowing each party to obtain a high-quality business prediction model.

[0016] Federated learning can be conducted under a variety of implementation architectures.

[0017] Figure 1 is a schematic diagram of an implementation architecture for federated learning provided in an embodiment of this specification. Referring to Figure 1, through information interaction between collaborating parties and multiple business parties, relevant federated learning tasks can be completed using business data held by each of the multiple business parties, i.e., training relevant business prediction models. Collaborating parties may include, but are not limited to, centralized servers, and business parties may include, but are not limited to, edge computing devices acting as clients, such as personal computers or mobile phones, thus forming a client-server architecture. It should be noted that in practical application scenarios, federated learning tasks can also adopt a peer-to-peer network architecture, which may include multiple business parties but not necessarily collaborating parties.

[0018] For example, in a client-server architecture for federated learning, business units can use their own business data to train a business prediction model and obtain gradient information for updating model parameters. Multiple business units send their obtained gradient information to a collaborating unit after privacy processing. The collaborating unit aggregates the privacy-processed gradient information and returns the aggregated gradient information to multiple business units, which can then use the aggregated gradient information to update the model parameters.

[0019] The forecasting transactions depend on the expected business forecasting model. Different business forecasting models may employ the same or different machine learning algorithms. The machine learning algorithm defines the structure of the business forecasting model and its process for processing input data. For example, it defines the number of network layers included in the business forecasting model, the basic configuration of each network layer, and the connections between network layers. In other words, a machine learning algorithm essentially refers to the original machine learning model that has not been trained using relevant training samples. The types of machine learning algorithms used by business forecasting models may include, but are not limited to, linear algorithms, decision trees, support vector machines (SVM), convolutional neural networks (CNN), long short-term memory networks (LSTM), and recurrent neural networks (RNN). Linear algorithms may include, but are not limited to, subtypes such as logistic regression and linear regression. Decision trees may include, but are not limited to, subtypes such as extreme gradient boosting trees (XGBoost), gradient boosting decision trees (GBDT), and random forests. The trained business prediction model can include, but is not limited to, Natural Language Processing (NLP) models, Computer Vision (CV) models, and Large Language Models (LLMs) used to perform prediction transactions.

[0020] Implementing federated learning typically requires deploying the client-side of the federated learning platform on the relevant business parties. For federated learning implemented using a client-server architecture, the server-side of the federated learning platform also needs to be deployed on the collaborating parties. Currently, federated learning platforms are usually closed systems. This means that multiple business parties purchase a federated learning platform from a single service provider, and after deploying the client-side of the federated learning platform on their respective business devices, these parties can only use the machine learning algorithms built into the client to perform federated learning tasks. This makes it difficult to meet the personalized needs of business parties for the algorithms used in their business prediction models.

[0021] Therefore, this specification provides a federated learning method and apparatus in its embodiments. For the first participant among multiple participants executing a federated learning task, after determining the machine learning algorithm required for the task, it can obtain a target application corresponding to the machine learning algorithm from a preset algorithm repository by running a node program of the federated learning platform. The target application is then loaded into the node program, and the federated learning task is jointly executed with the other participants through this target application. In this way, the application corresponding to the machine learning algorithm does not need to be directly integrated into the client or server of the federated learning platform. Relevant participants can load and use the target application corresponding to the relevant machine learning algorithm as needed, which better meets the personalized needs of users for the machine learning algorithm used in the federated learning task to be executed or the business prediction model they expect to obtain, resulting in a better user experience.

[0022] As mentioned above, depending on the implementation architecture adopted by federated learning, the federated learning platform includes at least a client deployed on the business side, and may also include a server deployed on the collaborating side. Therefore, the application corresponding to a single machine learning algorithm includes at least a first application (hereinafter referred to as the algorithm program) that needs to run on the business side's device and be accessible to the client, and may also include a second application (hereinafter referred to as the aggregation program) that needs to run on the collaborating side's device and be accessible to the server. The algorithm program and the aggregation program corresponding to the same machine learning algorithm can be packaged into the same algorithm package, which can be uploaded to an algorithm repository that allows relevant business side devices and collaborating side devices to download it on demand.

[0023] For example, referring to the implementation architecture shown in Figure 1, relevant developers can upload algorithm package P1 corresponding to machine learning algorithm P1 and algorithm package P2 corresponding to machine learning algorithm P2 to a designated algorithm repository; wherein algorithm package P1 includes aggregation program P1-S and algorithm program P1-C, and algorithm package P2 includes aggregation program P2-S and algorithm program P2-C.

[0024] The name of the algorithm package corresponding to a machine learning algorithm is usually the algorithm identifier of that algorithm. The algorithm identifier of a machine learning algorithm can be determined based on one or more of the following: algorithm type (e.g., CV, NLP, Graph, and LLM), version number, and developer / service provider identification information. The program identifier of an algorithm program can include the algorithm identifier of the machine learning algorithm and indication information representing the algorithm program, such as C. The program identifier of an aggregation program can include, for example, the algorithm identifier of the machine learning algorithm and indication information representing the aggregation program, such as S.

[0025] To enable the client and server sides of the federated learning platform to load and use the corresponding algorithm programs and aggregation programs for various possible machine learning algorithms on demand, the service provider of the federated learning platform can provide a unified software development kit (SDK). The SDK can provide various application programming interfaces (APIs) that can be used by the algorithm programs and aggregation programs.

[0026] For example, the aforementioned SDK can provide a first abstract base class (denoted as Client Base API) corresponding to the algorithm program. When developing an algorithm program corresponding to any machine learning algorithm, developers can write a first derived class by inheriting from the Client Base API. This first derived class can then implement the logic for certain predefined transactions according to the developer's needs. This ensures that after loading the corresponding algorithm program, the client can call an instance of the first derived class to complete the relevant predefined transactions according to the developer's requirements. For instance, the Client Base API can define a virtual function (denoted as nit_epoch_data) for loading training samples and a virtual function (train_step) for training the business prediction model. Developers can write the implementation logic for nit_epoch_data and train_step in the first derived class. The client can then call an instance of the first derived class to complete the relevant transactions according to the developer's nit_epoch_data and train_step implementation logic.

[0027] For example, the aforementioned SDK can provide a second abstract base class (denoted as Server Base API) corresponding to the aggregation program. When developing an aggregation program for any machine learning algorithm, developers can write a second derived class by inheriting from Server Base API. This second derived class can then implement custom logic for certain predefined transactions according to the developer's needs. This ensures that after loading the corresponding aggregation program, the server can call an instance of this second derived class in the relevant program component to complete the predefined transactions as required by the developer. For instance, Server Base API can define virtual functions for aggregating gradient information (denoted as Gradient aggregation). Developers can then write the implementation logic for Gradient aggregation in the second derived class. The server can then call an instance of the second derived class to perform the aggregation processing of gradient information from multiple business devices according to the developer's Gradient aggregation implementation logic.

[0028] For example, the aforementioned SDK may provide one or more of the following components: program components for supporting algorithm programs and / or aggregation programs in performing communication transactions, wherein such program components may include, but are not limited to, APIs such as: message passing interface (MPI), NVIDIA Collective Communication Library (NCCL), Remote Procedure Call (gRPC); program components for supporting algorithm programs and / or aggregation programs in performing privacy processing transactions, wherein such program components may include, but are not limited to, APIs for implementing secure aggregation, secure comparison, differential privacy, and other transactions; and program components for supporting algorithm programs in obtaining training samples, wherein such program components may include, but are not limited to, APIs for obtaining training samples in various data formats such as Comma-Separated Values ​​(CSV) and Optimized Row Columnar (ORC) from data sources such as files and other Object Storage Services (OSS).

[0029] When developers use the aforementioned SDK to write source code for various machine learning algorithms and / or aggregation programs, they can accelerate the development process by directly calling relevant components in the source code. Correspondingly, when the source code is packaged into algorithm programs and / or aggregation programs using the corresponding packaging tools, the called components can be included in the algorithm programs and / or aggregation programs.

[0030] Once the algorithm package corresponding to a certain machine learning algorithm is uploaded to the algorithm repository that allows relevant business devices and / or collaborating devices to download it, the business devices and collaborating devices can download and use the corresponding algorithm program or aggregation program from the algorithm repository as needed, with the support of their respective installed clients and servers, to execute relevant federated learning tasks.

[0031] The following describes in detail a method for executing a federated learning task provided in the embodiments of this specification. This federated learning task involves multiple participants, and the method can be executed by a first participant among these participants. Referring to the preceding text, the first participant can correspond to a business device that has a client-side device of the federated learning platform deployed, or a collaborating device that has a server-side device of the federated learning platform deployed.

[0032] Referring to Figure 2, the method may include, but is not limited to, some or all of the following steps S201 to S203.

[0033] Step S201: By running the node program of the federated learning platform, the target application corresponding to the machine learning algorithm required for the federated learning task to be executed is obtained. The target application comes from a pre-set algorithm repository. The programs in the algorithm repository are all developed based on a consistent software development kit (SDK), which corresponds to the federated learning platform.

[0034] Any participant among multiple participants can create a federated learning task to be executed through its deployed client, select other participants who need to jointly execute the federated learning task, and ultimately determine the target machine learning algorithm to be used for the federated learning task by exchanging information with the selected other participants.

[0035] Referring to Figure 1, both business device A and B have clients deployed on the federated learning platform, while the collaborating device has the server deployed on the same platform. Business device A can create a federated learning task T to be executed through its deployed client, select the other participants to jointly execute the task (including business device B and the collaborating device), and send task information corresponding to task T to business device B and the collaborating device. This task information may include, but is not limited to, the task identifier of task T and the algorithm identifier (e.g., P1) of the target machine learning algorithm that business device A expects to use. Correspondingly, business device B and the collaborating device can learn from the task information from business device A that the algorithm identifier of the target machine learning algorithm to be executed is P1.

[0036] If the first participant is a business entity, the target application can be the algorithm program corresponding to the target machine learning algorithm. For example, any business entity device, such as business entity device A, after learning that the algorithm identifier of the target machine learning algorithm is P1, can first query whether the algorithm program P1-C corresponding to the target machine learning algorithm P1 already exists in business entity device A based on the algorithm identifier P1. If it exists, the algorithm program P1-C is directly used as the target application to be loaded in the subsequent step S203; otherwise, the algorithm program P1-C corresponding to the target machine learning algorithm P1 can be downloaded from the corresponding algorithm library based on the algorithm identifier P1, and the downloaded algorithm program P1-C is used as the target application to be loaded in the subsequent step S203.

[0037] Referring to the preceding text, the node program mentioned here can be a client or server of the federated learning platform.

[0038] If the first participant is a collaborator, the target application can be an aggregate program corresponding to the target machine learning algorithm. For example, after learning that the algorithm identifier of the target machine learning algorithm is P1, the collaborator device can first query whether the aggregate program P1-S corresponding to the target machine learning algorithm P1 already exists in the collaborator device based on the algorithm identifier P1. If it exists, the aggregate program P1-S is directly used as the target application to be loaded in the subsequent step S205; otherwise, the aggregate program P1-S corresponding to the target machine learning algorithm P1 can be downloaded from the corresponding algorithm library based on the algorithm identifier P1, and the downloaded aggregate program P1-S is used as the target application to be loaded in the subsequent step S203.

[0039] Step S205: Load the target application in the node program, and jointly execute the federated learning task with the remaining participants among the multiple participants through the target application.

[0040] The process by which any participating party uses the loaded target application to perform federated learning tasks is described above.

[0041] Continuing the previous example, when business device A loads the algorithm program P1-C of machine learning algorithm P1 using the client of its deployed federated learning platform, it can call algorithm program P1-C through the client to start running and implement the following: obtaining training samples from the data source corresponding to business device A through the corresponding program component; loading the obtained training samples using an instance of the first abstract base class in algorithm program P1-C and using the loaded training samples and the target machine learning algorithm P1 defined in algorithm program P1-C through the corresponding program component to perform a training process on the business prediction model to obtain the corresponding gradient information; performing privacy processing on the gradient information through the corresponding program component; and sending the privacy-processed gradient information in ciphertext to the collaborating device through the corresponding program component. The same applies to business device B.

[0042] Correspondingly, when the collaborating device loads the aggregation program P1-S of the machine learning algorithm P1 using the server of its deployed federated learning platform, it can call the aggregation program P1-S through the server, so that the aggregation program P1-S starts running and implements the following: by using an instance of the second abstract base class in the aggregation program, it aggregates the gradient information ciphertext from business device A and business device B, and returns the aggregated gradient information ciphertext to business devices A and B through the corresponding program components.

[0043] Finally, business devices A and B can use the corresponding components in algorithm program P1-C to process the aggregated gradient information ciphertext from collaborating devices into gradient information plaintext, and use the gradient information plaintext to update the model parameters of the business prediction model.

[0044] The business side's equipment can obtain a trained business prediction model by updating the model parameters of the business prediction model in multiple rounds.

[0045] Based on the same concept as the aforementioned method embodiments, this specification also provides a computing device 300, which corresponds to a first participant among multiple participants. The computing device includes: a program acquisition unit 301, configured to acquire the target application corresponding to the machine learning algorithm required for the federated learning task to be executed by running a node program of the federated learning platform. The target application comes from a pre-set algorithm repository, and the programs in the algorithm repository are all developed based on a consistent software development kit (SDK), which corresponds to the federated learning platform; and a program scheduling unit 303, configured to load the target application in the node program and jointly execute the federated learning task with the other participants among the multiple participants through the target application.

[0046] This specification also provides a computer-readable storage medium storing a computer program / instruction, which, when executed in a computer, causes the computer to perform a federated learning task execution method executed by a computing device in the foregoing embodiments.

[0047] This specification also provides a computing device in its embodiments, including a memory and a processor. The memory stores computer programs / instructions, and when the processor executes the computer programs / instructions, it implements a method for executing a federated learning task performed by the computing device in the foregoing embodiments.

[0048] In the 1990s, improvements to a technology could be clearly distinguished as either hardware improvements (e.g., improvements to the circuit structure of diodes, transistors, switches, etc.) or software improvements (improvements to the methodology). However, with technological advancements, many methodological improvements today can be considered direct improvements to the hardware circuit structure. Designers almost always obtain the corresponding hardware circuit structure by programming the improved methodology into the hardware circuit. Therefore, it cannot be said that a methodological improvement cannot be implemented using hardware physical modules. For example, a Programmable Logic Device (PLD) (such as a Field Programmable Gate Array (FPGA)) is such an integrated circuit whose logic function is determined by the user programming the device. Designers can program and "integrate" a digital system onto a PLD themselves, without needing chip manufacturers to design and manufacture dedicated integrated circuit chips. Furthermore, nowadays, instead of manually manufacturing integrated circuit chips, this programming is mostly implemented using "logic compiler" software. Similar to the software compiler used in program development, the original code before compilation must be written in a specific programming language, called a Hardware Description Language (HDL). There are many HDLs, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, and RHDL (Ruby Hardware Description Language). Currently, VHDL (Very-High-Speed ​​Integrated Circuit Hardware Description Language) and Verilog are the most commonly used. Those skilled in the art should understand that by simply performing some logic programming on the method flow using one of these hardware description languages ​​and programming it into an integrated circuit, the hardware circuit implementing the logical method flow can be easily obtained.

[0049] The controller can be implemented in any suitable manner. For example, it can take the form of a microprocessor or processor and a computer-readable medium storing computer-readable program code (e.g., software or firmware) executable by the (micro)processor, logic gates, switches, application-specific integrated circuits (ASICs), programmable logic controllers, and embedded microcontrollers. Examples of controllers include, but are not limited to, the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicon Labs C8051F320. A memory controller can also be implemented as part of the control logic of the memory. Those skilled in the art will also recognize that, in addition to implementing the controller in purely computer-readable program code form, the same functionality can be achieved by logically programming the method steps to make the controller take the form of logic gates, switches, application-specific integrated circuits, programmable logic controllers, and embedded microcontrollers. Therefore, such a controller can be considered a hardware component, and the means included therein for implementing various functions can also be considered as structures within the hardware component. Alternatively, the means for implementing various functions can be considered as both software modules implementing the method and structures within the hardware component.

[0050] The systems, devices, modules, or units described in the above embodiments can be implemented by computer chips or physical entities, or by products with certain functions. A typical implementation device is a server system. Of course, this application does not exclude the possibility that, with the future development of computer technology, the computer implementing the functions of the above embodiments can be, for example, a personal computer, a laptop computer, an in-vehicle human-machine interaction device, a cellular phone, a camera phone, a smartphone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or any combination of these devices.

[0051] While one or more embodiments of this specification provide the operational steps of the methods described in the embodiments or flowcharts, more or fewer operational steps may be included based on conventional or non-inventive means. The order of steps listed in the embodiments is merely one possible order of execution among many steps and does not represent the only possible order. In actual device or end product execution, the methods shown in the embodiments or drawings may be executed sequentially or in parallel (e.g., in a parallel processor or multi-threaded processing environment, or even a distributed data processing environment). The terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, product, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, product, or apparatus. Without further limitations, the presence of other identical or equivalent elements in the process, method, product, or apparatus that includes the elements is not excluded. For example, the use of terms such as "first," "second," etc., is to denote names and does not indicate any particular order.

[0052] For ease of description, the above devices are described in terms of function, divided into various modules. Of course, when implementing one or more of these specifications, the functions of each module can be implemented in one or more software and / or hardware components, or a module that performs the same function can be implemented by a combination of multiple sub-modules or sub-units. The device embodiments described above are merely illustrative. For example, the division of units is only a logical functional division; in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces, indirect coupling or communication connection between devices or units, and may be electrical, mechanical, or other forms.

[0053] This invention is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in one or more blocks of the flowchart illustrations and / or one or more blocks of the block diagrams.

[0054] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means that implement the functions specified in one or more flowcharts and / or one or more block diagrams.

[0055] These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer-implemented process, such that the instructions, which execute on the computer or other programmable apparatus, provide steps for implementing the functions specified in one or more flowcharts and / or one or more block diagrams.

[0056] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0057] Memory may include non-persistent storage in computer-readable media, such as random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash RAM. Memory is an example of computer-readable media.

[0058] Computer-readable media includes both permanent and non-permanent, removable and non-removable media that can store information by any method or technology. Information can be computer-readable instructions, data structures, modules of programs, or other data. Examples of computer storage media include, but are not limited to, phase-change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, CD-ROM, digital versatile optical disc (DVD) or other optical storage, magnetic tape, magnetic disk storage, graphene storage or other magnetic storage devices, or any other non-transferable medium that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transient computer-readable media, such as modulated data signals and carrier waves.

[0059] Those skilled in the art will understand that one or more embodiments of this specification can be provided as a method, system, or computer program product. Therefore, one or more embodiments of this specification may take the form of a completely hardware embodiment, a completely software embodiment, or an embodiment combining software and hardware aspects. Furthermore, one or more embodiments of this specification may take the form of a computer program product implemented on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0060] One or more embodiments of this specification can be described in the general context of computer-executable instructions, such as program modules, that are executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc., that perform a particular task or implement a particular abstract data type. One or more embodiments of this specification can also be practiced in distributed computing environments where tasks are performed by remote processing devices connected via a communication network. In distributed computing environments, program modules can reside in local and remote computer storage media, including storage devices.

[0061] The various embodiments in this specification are described in a progressive manner. Similar or identical parts between embodiments can be referred to mutually. Each embodiment focuses on describing the differences from other embodiments. In particular, system embodiments are basically similar to method embodiments, so the description is relatively simple; relevant parts can be referred to the descriptions in the method embodiments. In the description of this specification, the terms "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., refer to specific features, structures, materials, or characteristics described in connection with that embodiment or example, which are included in at least one embodiment or example of this specification. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described can be combined in any suitable manner in one or more embodiments or examples. Moreover, without contradiction, those skilled in the art can combine and integrate the different embodiments or examples described in this specification and the features of different embodiments or examples.

[0062] The above description is merely an embodiment of one or more embodiments of this specification and is not intended to limit the scope of these embodiments. Various modifications and variations can be made to these embodiments by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of this specification should be included within the scope of the claims.

Claims

1. A method for executing a federated learning task, the method involving multiple participants, the method being executed by a first participant among the multiple participants, the method comprising: By running the node program of the federated learning platform, the target application corresponding to the machine learning algorithm required for the federated learning task to be executed is obtained. The target application comes from a pre-set algorithm repository. The programs in the algorithm repository are all developed based on a consistent software development kit (SDK), and the SDK corresponds to the federated learning platform. The target application is loaded into the node program, and the federated learning task is jointly executed with the remaining participants among the plurality of participants through the target application.

2. The method according to claim 1, wherein the plurality of participants include a collaborating party and a plurality of business parties, and the business parties hold training samples for training the business prediction model.

3. The method according to claim 2, wherein the first participant belongs to the plurality of business parties, and the node program is a client of the federated learning platform; wherein, The target application includes a first program component for implementing the machine learning algorithm.

4. The method according to claim 3, wherein the SDK includes a first abstract base class; wherein, The target application also includes a second program component, which includes a first derived class that inherits from the first abstract base class, used to define the implementation logic of the first transaction.

5. The method according to claim 4, wherein the first transaction includes loading training samples or training a business prediction model.

6. The method according to claim 4, wherein the SDK further comprises at least one of the following program components: a third program component for supporting the target application in performing communication transactions, a fourth program component for supporting the target application in performing privacy processing transactions, and a fifth program component for supporting the target application in obtaining training samples.

7. The method according to claim 2, wherein the first participant is the collaborating party, the node program is the server-side of the federated learning platform, and the SDK includes a second abstract base class; wherein, The target application includes a sixth program component, which includes a second derived class that inherits from the second abstract base class and is used to define the implementation logic of the second transaction.

8. The method according to claim 7, wherein the second transaction includes aggregating gradient information from the plurality of business parties, the gradient information being obtained by the corresponding business party during the process of training the business prediction model using training samples held by it.

9. The method according to any one of claims 1-8, wherein obtaining the target application corresponding to the machine learning algorithm required for the federated learning task comprises: Download the target application from the algorithm repository.

10. A computing device, the computing device corresponding to a first participant among a plurality of participants, the computing device comprising: The program acquisition unit is configured to obtain the target application corresponding to the machine learning algorithm required for the federated learning task to be executed by running the node program of the federated learning platform. The target application comes from a pre-set algorithm repository. The programs in the algorithm repository are all developed based on a consistent software development kit (SDK), and the SDK corresponds to the federated learning platform. The program scheduling unit is configured to load the target application in the node program and jointly execute the federated learning task with the remaining participants among the plurality of participants through the target application.

11. A computer-readable storage medium having a computer program stored thereon, wherein when the computer program is executed in a computing device, the computing device performs the method of any one of claims 1-9.

Images