JP7548432B2 - How to learn - Google Patents

Description

The present invention relates to a learning method using associative learning.

Among the model learning methods used in machine learning and deep learning, federated learning is one technique in which multiple client machines participate in learning in a distributed environment.

As an example of a learning format for federated learning, there is a format as shown in FIG. 1. Federated learning is implemented by a central server 50 that manages the learning, and clients 60-1 to 60-K, which are information processing devices that perform the learning itself. The central server 50 includes a client communication device 51 that transmits parameters of the machine learning/deep learning model to be learned to the clients, and a model aggregation device 52 that aggregates the trained models transmitted from the clients and updates the model parameters. The clients 60-1 to 60-K individually learn using their own unique data sets stored by each client. Examples of such federated learning are described in Non-Patent Document 1, Patent Document 1, and Patent Document 2.

Here, the federated learning system described in Non-Patent Document 1 operates, for example, as shown in the flowchart of Figure 2. As described above, federated learning by the federated learning system is carried out by the central server 50 and all clients 60-1 to 60-K participating in the learning.

First, the central server 50 inputs parameters as necessary when starting learning (step S51). Then, the federated learning system repeats a series of procedures, defined as a round below, for a set number of times or until a set evaluation index is reached as the federated learning. The operation of one round is as follows.

At the start of a round, the central server 50 selects K clients 60-1 to 60-K that will participate in the learning in that round by drawing lots from among all clients (assumed to be N) (step S52). At this time, the number of clients K selected is 1 or more and N or less. Note that FIG. 1 illustrates only the K clients 60-1 to 60-K that will participate in the learning in each round, rather than all N clients in advance. For example, in the case of federated learning in a high-computing environment using server machines owned by research institutions, etc., where N is a few to about 100, learning with the number K set to about 80% of the number N is considered. On the other hand, in the case of federated learning using mobile terminals owned by general users, where N is tens of thousands or more, learning with the number K set to about 10% of the number N is considered.

Next, the central server 50 transmits the machine learning/deep learning model (global model) to be trained to all of the K clients 60-1 to 60-K selected by lottery (step S53). After receiving the global model, the K clients 60-1 to 60-K each individually train using the data stored in the client (step S54). As soon as the training is completed, the K clients 60-1 to 60-K each transmit the trained model (local model) to the central server 50 (step S55). The central server 50 performs an aggregation operation on the local models transmitted from each client 60-1 to 60-K in a predetermined manner, and updates the global model using the results of the operation (step S56). The above is the operation of one round of federated learning, and the learning progresses by using the update result of the global model in the previous round as the global model transmitted to the client in the next round. When the training has progressed for a predetermined number of rounds or when a predetermined evaluation index has been reached, all the training processes are terminated (Yes in step S57).

Here, in the above-mentioned federated learning, the central server 50 transmits the global model to the client devices 60-1 to 60-K at each point in the learning. Therefore, if a malicious attacker participates in the learning as a client, the attacker can automatically obtain the model information, and can perform a more sophisticated attack than if the attacker did not have the model information. For example, an attacker may perform an attack using adversarial examples as described below to hinder the model's normal learning, induce the model to malfunction after learning is completed, or steal information that violates privacy, such as restoring learning data from model information.

In addition, as an attack on a machine learning/deep learning model, an attack by an adversarial sample can be mentioned. An adversarial sample is data to which perturbations calculated to cause a machine learning/deep learning model to malfunction are intentionally added. An adversarial sample is a problem that can occur in any machine learning/deep learning model, and is a serious security issue. Up to now, no machine learning/deep learning model that is not affected by adversarial samples has been proposed, and in order to improve the robustness of security, some additional defensive measures must be added. Among these, one of the most useful defensive methods known to date is adversarial learning. An example of such adversarial learning is described in Non-Patent Document 2.

Adversarial learning works, for example, as shown in the flowchart in Figure 3. Here, the adversarial learning described below is performed on a single machine, and when combined with federated learning, such adversarial learning on a single machine corresponds to learning on one of multiple clients performing federated learning. Adversarial learning repeats the following process a set number of times, or until the model performance reaches a set evaluation index.

Specifically, in adversarial learning, first, the client performing the learning selects data to be used to update the model from the dataset (step S61). Next, the client uses the selected data to generate adversarial samples for the model at the current learning progress (step S62). At this time, although there are differences depending on the generation method, the generation of the adversarial samples generally requires about 10 iterative calculations (step S63). After that, the client updates the model parameters using the generated adversarial samples (step S64). Then, when a predetermined amount of data or its repetitions, or when a predetermined evaluation index is reached, the entire learning process ends (step S65).

Special Publication No. 2020-528588 (WO2019/032157) Special Publication No. 2020-528589 (WO2019/032156)

Peter Kairouz et al., “Advances and Open Problems in Federated Learning”, 2016 arXiv Aleksandar Madry et al., “Towards deep learning models resistant to adversarial attacks”, ICLR, 2018

Here, in the adversarial learning described above, a separate iterative calculation is performed each time to generate an adversarial sample within the iterative calculation that is also included in the normal learning method of updating the model by selecting data. This causes a problem of long calculation times. In particular, when adversarial learning is performed within the framework of federated learning as described above, the adversarial learning algorithm is processed by the client, but there are various types of client machines in federated learning, and they are not necessarily limited to computers with powerful CPUs, GPUs, or abundant memory. For example, depending on the application, it is assumed that the client machine in federated learning may be a device with poor computing resources, such as a smartphone. In such cases, in addition to the long calculation times due to the above-mentioned adversarial learning algorithm, the calculation times will also be long due to the poor computing power of the client.

Therefore, the object of the present invention is to provide a learning method that can solve the above-mentioned problem of the increasing calculation time in associative learning.

A learning method according to one aspect of the present invention includes:
A learning method using federated learning in which a plurality of client devices execute learning for the same model, comprising:
assigning each of the plurality of client devices to perform learning using at least two or more different learning methods that have been set in advance;
aggregating the models generated after training by the plurality of client devices;
The structure is as follows.

Furthermore, the learning device according to one aspect of the present invention comprises:
A learning device using federated learning that causes multiple client devices to learn the same model,
an allocation unit that allocates, to each of the plurality of client devices, learning to be performed using one of at least two or more different learning methods that are set in advance;
A counting unit that counts models generated after learning by the multiple client devices;
Equipped with
The structure is as follows.

In addition, a program according to one aspect of the present invention includes:
In the information processing device,
When performing federated learning in which a plurality of client devices are made to perform learning on the same model, each of the plurality of client devices is assigned to perform one of learning methods using at least two or more different learning methods that are set in advance;
aggregating the models generated after training by the plurality of client devices;
Execute the process,
The structure is as follows.

By being configured as described above, the present invention can provide a learning method that can prevent the calculation time in associative learning from increasing.
is located.

FIG. 1 is a block diagram showing an example of the configuration of a federated learning system. 1 is a flowchart showing an example of the operation of the federated learning system. 11 is a flowchart illustrating an example of an operation of adversarial learning. 1 is a block diagram showing a configuration of a federated learning system according to a first embodiment of the present invention. 5 is a flowchart showing the operation of the federated learning system disclosed in FIG. 4 . FIG. 5 is a sequence diagram showing the operation of the federated learning system disclosed in FIG. 4 . FIG. 11 is a block diagram showing a configuration of a federated learning system according to a second exemplary embodiment of the present invention. 8 is a flowchart showing the operation of the federated learning system disclosed in FIG. 7 . 11 is a table showing a comparison of the effects of the learning method of the present invention and other learning methods. FIG. 13 is a block diagram showing a hardware configuration of a learning device according to a third embodiment of the present invention. FIG. 13 is a block diagram showing a configuration of a learning device according to a third embodiment of the present invention. 13 is a flowchart showing the operation of a learning device in a third embodiment of the present invention.

First Embodiment
A first embodiment of the present invention will be described with reference to Figures 4 to 6. Figure 4 is a diagram for explaining the configuration of a federated learning system, and Figures 5 and 6 are diagrams for explaining the operation of the federated learning system.

The federated learning system of the present invention can be particularly applied to tasks where adversarial learning is applicable. For example, the federated learning system of the present invention can be used to generate models for classifying or authenticating images or sounds. However, the federated learning system of the present invention may be used in any field.

[composition]
As shown in Fig. 1, the federated learning system in the first embodiment includes a plurality of (any number N) client learning devices (hereinafter also referred to as "clients") and a central server 10. Here, Fig. 1 illustrates only K client learning devices 20-1 to 20-K that participate in learning selected by lottery in each round as described below. Each of the client learning devices 20-1 to 20-K and the central server 10 are connected to be able to communicate with each other.

The central server 10 includes therein a client communication device 11, a model calculation device 12, and a client allocation device 13. The client communication device 11 and the model calculation device 12, and the client communication device 11 and the client allocation device 13 are connected to each other in the middle of the central server 10.

The present invention can also be realized as a federated learning program that causes a computer, i.e., the central server 10, to function as a federated learning system. The central server 10, which is a computer, includes a central processing unit (CPU (Central Processing Unit)) into which the federated learning program is loaded and executed, a storage device (hard disk, etc.) that stores data individually in the clients and stores a global model in the central server 10, an input device 15 that is an input means such as a keyboard or mouse, and a display device that is a display means such as a display.

In the first embodiment of the present invention, the federated learning program loaded into the CPU of the central server 10 constructs the above-mentioned client communication device 11, model aggregation device 12, and client allocation device 13 in the CPU. Each component will be described below.

The client allocation device 13 (allocation unit) specifies whether the clients 20-1 to 20-K participating in the learning in each round will perform normal learning or adversarial learning. This specification of the learning method is transmitted to all clients 20-1 to 20-K participating in the learning in each round through the client communication device 11. At the start of learning, the client allocation device 13 receives as input the ratio at which normal learning and adversarial learning are allocated to the clients 20-1 to 20-K in each round. The allocation ratio of these two learning methods may be input from outside at the start of learning, or may be automatically calculated from information on the task, model structure, and data of the model to be learned. The learning method may be assigned to each client completely randomly, for example, or may be assigned according to the computing resources, processing speed, and information on the data held by each client. As an example, the total number of clients participating in learning is several to about 100 in the case of learning using a machine that holds relatively large amounts of data such as data centers and companies and has excellent computing power. As another example, the total number of clients participating in learning is several million or more in the case of learning using clients with few computational resources such as smartphones. Then, for example, normal learning and adversarial learning are assigned to these clients in a ratio of "5:5" or "3:7". However, the total number of clients and the assignment ratio to each learning are not limited to the above values.

In this embodiment, the client allocation device 13 assigns normal learning to at least one of the selected clients 20-1 to 20-K, and assigns adversarial learning to at least one of the selected clients. However, depending on the situation, the client allocation device 13 may assign either learning method to all selected clients. For example, the client allocation device 13 may assign normal learning and adversarial learning in a ratio of "10:0" or "0:10". As an example, the client allocation device 13 may assign normal learning and adversarial learning in a ratio of "10:0" or "0:10" in some of the total rounds when one learning session, called a round, is repeated multiple times, as described below.

Furthermore, the learning method that the client assignment device 13 assigns to a client is not necessarily limited to normal learning and adversarial learning. For example, the client assignment device 13 may assign to a client a predetermined first learning and a second learning having a different learning method from the first learning. In this case, the first learning and the second learning are performed on the same model. Furthermore, the client assignment device 13 is not necessarily limited to assigning two different learnings to a client, and may assign three or more different learnings.

The client communication device 11 (allocation unit, aggregation unit) has the function of transmitting a global model to clients 20-1 to 20-K participating in learning in each round, and transmitting the learning method determined by the client allocation device 13 to each client. The client communication device 11 also receives local models from clients 20-1 to 20-K that have completed learning. In other words, each client learns using its own data as described below, and transmits a local model, which is a learned model of the learning results, to the central server 10, and the client communication device 11 receives the local model.

As described below, each client 20-1 to 20-K performs either "normal learning" or "adversarial learning" in which adversarial samples are generated from the learning data at each step of the learning and the adversarial samples are used as the learning data, depending on the learning method assigned to it. At this time, the learning program executed by each client 20-1 to 20-K and the program for the subroutine for generating adversarial samples when performing adversarial learning are transmitted to each client 20-1 to 20-K by, for example, the client communication device 11. As a result, the clients 20-1 to 20-K obtain the above-mentioned programs when the federated learning starts, or when it is decided that the client will participate in the learning in each round of the learning. Note that the programs used for the learning executed by the clients 20-1 to 20-K are not necessarily limited to those provided by the client communication device 11, and the clients 20-1 to 20-K may obtain them by other methods.

The model counting device 12 aggregates the local models received by the client communication device 11 from the clients 20-1 to 20-K through computation according to a predetermined federated learning algorithm, and updates the global model using the results. Specifically, the global models sent to the clients participating in the learning in each round are independently trained using the unique data of each client 20-1 to 20-K, and the local models resulting from the learning are individually transmitted from each client 20-1 to 20-K to the client communication device 11. The model counting device 12 then calculates the weight parameters of the new global model using an averaging algorithm, such as the arithmetic mean of the weight parameters of each local model, or an average value that excludes outliers or uses only values near the median. This newly updated global model is transmitted to the clients 20-1 to 20-K in the next round by the client communication device 11, as described above.

The client learning devices 20-1 to 20-K receive the global model transmitted from the central server 10, and perform learning on the global model using the individual learning data on each client 20-1 to 20-K. At this time, the clients 20-1 to 20-K perform learning using the learning method assigned by the client allocation device 13 as described above. For example, the clients 20-1 to 20-K perform normal learning, which is learning using normal data as is, or perform adversarial learning. As the learning data, for example, data that requires careful handling from the viewpoint of privacy, such as face image data included in a photo taken with a smartphone, can be used.

When performing adversarial learning, clients 20-1 to 20-K repeat the following series of processes called rounds a predetermined number of times or until the model performance reaches a predetermined evaluation index. First, as with normal learning, at each step of learning, clients 20-1 to 20-K select data to be used for learning from the data they hold. Next, clients 20-1 to 20-K use the selected data to generate adversarial samples for the model at the current learning progress. Thus, unlike the normal learning described above, adversarial learning adds a process of generating adversarial samples. After that, adversarial learning is performed on the global model using the generated adversarial samples, and the model parameters are updated.

As described above, the learning method to be performed by clients 20-1 to 20-K is determined by the client allocation device 13 and notified to the clients via the client communication device 11. For example, the example in FIG. 1 illustrates a case in which M clients, designated 20-1 to 20-M, perform normal learning, and (K-M) clients, designated 20-(M+1) to 20-K, perform adversarial learning. Then, as soon as each client 20-1 to 20-K has completed learning using the specified method, it transmits the learned local model to the client communication device 11 of the central server 10.

[Action]
Next, the operation of the above-mentioned federated learning system will be described with reference to the flow chart of FIG. 5 and the sequence diagram of FIG.

First, the central server 10 receives input from the input device 15 of the ratio of allocation of normal learning and adversarial learning to the clients 20-1 to 20-K participating in learning in each round (step S1 in FIG. 5, step S11 in FIG. 6). The federated learning system then repeats the following learning process a predetermined number of times or until a predetermined evaluation index is reached. This repetitive process is called a round.

Then, at the start of a new round, the central server 10 selects clients 20-1 to 20-K to participate in the learning of that round from among all clients participating in the learning (step S2 in FIG. 5, step S12 in FIG. 6). The central server 10 transmits the global model to these selected clients 20-1 to 20-K (step S3 in FIG. 5, step S13 in FIG. 6). Next, the central server 10 assigns whether the selected clients 20-1 to 20-K will perform normal learning or adversarial learning in that round according to the input learning allocation ratio, and notifies the clients 20-1 to 20-K to learn using the assigned learning method (step S4 in FIG. 5, step S14 in FIG. 6). For example, as shown in FIG. 1, normal learning is assigned to M clients from 20-1 to 20-M, and adversarial learning is assigned to (K-M) clients from 20-(M+1) to 20-K.

Then, clients 20-1 to 20-K that have received the instruction to assign a learning method perform learning using the data set that they individually own with the assigned learning method (step S5 in FIG. 5). At this time, clients 20-1 to 20-M that have been assigned normal learning perform normal learning on the global model, which is learning using the data they hold as is, and generate a local model with updated model parameters (step S15 in FIG. 6). On the other hand, clients 20-(M+1) to 20-K that have been assigned adversarial learning first generate adversarial samples from the data they hold when performing adversarial learning. Then, clients 20-(M+1) to 20-K perform adversarial learning on the global model using the generated adversarial samples, and generate a local model with updated model parameters (step S16 in FIG. 6).

After that, the clients 20-1 to 20-K that have completed learning individually transmit their local models to the central server 10 (step S6 in FIG. 5, steps S17 and S18 in FIG. 6). The central server 10 aggregates the received local models from the multiple clients 20-1 to 20-K using a predetermined federated learning algorithm, updates the global model, and ends the round (step S7 in FIG. 5, steps S19 and S20 in FIG. 6). The updated global model will be sent by the central server 10 to the clients 20-1 to 20-M in the next round (No in step S8 in FIG. 5, S2, S3). Then, the central server 10 repeatedly executes the learning process called the above-mentioned round until the learning progresses for a predetermined number of rounds or a predetermined evaluation index is reached (No in step S8 in FIG. 5). On the other hand, if the central server 10 meets the learning end requirements (Yes in step S8 in FIG. 5), it ends all learning processes and outputs the learned global model to an output device not shown.

[effect]
As described above, in the federated learning system in the first embodiment, in each round, not all clients perform normal learning using normal data as in normal federated learning, nor do all clients perform adversarial learning, but rather, a certain ratio of some clients performs normal learning and the remaining clients perform adversarial learning. Therefore, learning using normal data can reduce computational resources compared to adversarial learning, and the overall amount of computation can be reduced while ensuring robustness against adversarial samples and accuracy for normal data.

Second Embodiment
Next, a second embodiment of the present invention will be described with reference to Figures 7 and 8. Figure 7 is a diagram for explaining the configuration of a federated learning system, and Figure 8 is a diagram for explaining the processing operation of the federated learning system.

[composition]
As shown in Fig. 7, in the federated learning system of this embodiment, in addition to the configuration of the central server 10 described in the first embodiment, the central server 10 further includes a client ratio adjustment device 14 (change unit). This client ratio adjustment device 14 is constructed in the CPU of the central server 10 by loading the federated learning program into the CPU. Note that the other components of the central server 10 are the same as those in the first embodiment, so they are denoted by the same reference numerals as in Fig. 1 and detailed description will be omitted.

The client ratio adjustment device 14 has a function of changing and updating the allocation ratio of the learning methods of the clients 20-1 to 20-K that participate in learning in each round based on a preset criterion. This configuration is the main difference from the first embodiment, and the main differences will be described in detail below.

The client ratio adjustment device 14 is connected to the client allocation device 13 at the center of the central server 10. The client ratio adjustment device 14 updates the allocation ratio of the learning method at each stage of learning, called a round, as described above, and transmits it to the client allocation device 13. The client allocation device 13 allocates the learning method to be performed by the clients 20-1 to 20-K participating in the learning in each round to each client according to the ratio transmitted from the client ratio adjustment device 14. The client ratio adjustment device 14 may receive as input the allocation ratio of the client's learning method at the start of learning in the form of a pair of the learning progress and the allocation ratio corresponding to that time. Alternatively, the client ratio adjustment device 14 may receive only the allocation ratio at the start of learning as input, and adaptively adjust the allocation ratio at each point of learning using the performance and statistics of the global model or multiple local models.

As an example of a method for adjusting the allocation ratio, for example, the learning allocation ratio is determined in advance for the progress of the round, and the client ratio adjustment device 14 changes the ratio according to the actual progress of the round. As an example, when a total of 100 rounds of learning are performed, the ratio of clients performing normal learning and clients performing adversarial learning may be 8:2 from the first 50 rounds, and then the ratio of clients performing normal learning and clients performing adversarial learning may be 2:5 from the 51st round to the 100th round, or the ratio may be changed gradually as the round progresses.

The client ratio adjustment device 14 may change the allocation ratio as follows. For example, when learning for 100 rounds, the ratio of clients performing normal learning and clients performing adversarial learning may be 10:0 from the first 50 rounds, i.e., all clients participating in learning perform normal learning, and thereafter the ratio may be 0:10, i.e., all clients participating in learning perform adversarial learning. In this way, the client ratio adjustment device 14 may change the allocation of learning methods to clients depending on the round and time.

As another example, the client ratio adjustment device 14 may change the learning ratio according to a specific index determined before the start of learning. For example, the performance of the global model and the local models of the learning results of each client are calculated at the end of each round, and the allocation ratio is changed if these exceed a certain threshold. In this case, the evaluation index of model performance may be, for example, the classification accuracy rate for normal data and the classification failure rate for adversarial samples for classification problems. Another possible method is to adjust the learning ratio according to statistics regarding the progress of learning, such as the degree to which these performance evaluation indexes vary or converge between each trained local model.

[Action]
Next, the operation of the above-mentioned associative learning system will be described with reference to the flowchart of Fig. 8. Note that operations similar to those in the first embodiment are given the same reference numerals as in Fig. 5, and detailed description thereof will be omitted.

The federated learning system in this embodiment differs from the first embodiment in the following points. In each round of learning, the client ratio adjustment device 14 of the central server 10 updates the global model in step S7, and then updates the allocation ratio of normal learning and adversarial learning to clients to be used in the next round according to the transition of the allocation ratio input in advance or by adaptive adjustment (step S7' in FIG. 8). For example, the client ratio adjustment device 14 changes the allocation ratio according to the progress of the round, or changes the allocation ratio according to the evaluation results of the generated local model and the updated global model. Then, if the central server 10 does not meet the requirements for ending learning (No in step S8 in FIG. 8), the client allocation device 13 assigns the learning method of the client with the changed allocation ratio and causes the client to learn.

[effect]
As described above, in this embodiment, the ratio of clients performing normal learning and adversarial learning is changed in each round. For example, in the early stage of learning, many clients perform normal learning, and as learning progresses, the ratio of adversarial learning is increased, thereby reducing the calculation time required for performing a lot of adversarial learning while ensuring the robustness of adversarial learning.

Figure 9 shows the results of evaluating the accuracy and learning time of the model generated by actually learning using the learning method of the present invention described above. Here, we deal with a 10-class image classification problem using public data. First, "Learning Method 1" is a case in which adversarial learning is incorporated into federated learning, and all clients perform adversarial learning at all points in learning. "Learning Method 2" is a case in which all clients perform learning using normal data in each round until 30% of the total number of learning rounds determined in advance is reached, and then all clients perform adversarial learning in each round. "Learning Method 3" is a case in which the ratio of clients performing adversarial learning among the clients participating in learning in each round increases stepwise from 0% to 70% every time 25% of the total learning rounds have passed. As evaluation indicators for models trained using these three methods, the classification accuracy for normal data, classification accuracy for adversarial samples, and the ratio of the number of iterative calculations required to complete learning for each model based on "Learning Method 1" were calculated. As shown in FIG. 9, “Learning Method 2” and “Learning Method 3” have succeeded in reducing the number of calculations while maintaining the same classification accuracy for normal data and adversarial samples as “Learning Method 1”.

<Embodiment 3>
Next, a third embodiment of the present invention will be described with reference to Fig. 10 to Fig. 12. Fig. 10 to Fig. 11 are block diagrams showing the configuration of a learning device in the third embodiment, and Fig. 12 is a flowchart showing the operation of the learning device. Note that this embodiment shows an outline of the configuration of the learning device and learning method described in the above embodiments.

First, the hardware configuration of the learning device 100 in this embodiment will be described with reference to Fig. 10. The learning device 100 is configured as a general information processing device, and is equipped with the following hardware configuration, as an example.
・CPU (Central Processing Unit) 101 (arithmetic unit)
・ROM (Read Only Memory) 102 (storage device)
・RAM (Random Access Memory) 103 (storage device)
Program group 104 loaded into RAM 103
A storage device 105 for storing the program group 104
A drive device 106 that reads and writes data from and to a storage medium 110 outside the information processing device.
A communication interface 107 that connects to a communication network 111 outside the information processing device
Input/output interface 108 for inputting and outputting data
A bus 109 that connects each component

The learning device 100 can be equipped with the allocation unit 121 and the tallying unit 122 shown in FIG. 11 by having the CPU 101 acquire and execute the program group 104. The program group 104 is stored in advance in the storage device 105 or ROM 102, for example, and is loaded into the RAM 103 and executed by the CPU 101 as necessary. The program group 104 may be supplied to the CPU 101 via the communication network 111, or may be stored in advance in the storage medium 110, and the drive device 106 may read out the program and supply it to the CPU 101. However, the allocation unit 121 and the tallying unit 122 described above may be constructed with dedicated electronic circuits for realizing such means.

Note that FIG. 10 shows an example of the hardware configuration of an information processing device that is the learning device 100, and the hardware configuration of the information processing device is not limited to the above-mentioned case. For example, the information processing device may be configured with a part of the above-mentioned configuration, such as not having the drive device 106.

Then, the learning device 100 executes the learning method shown in the flowchart of Figure 12 using the functions of the allocation unit 121 and the aggregation unit 122 constructed by the program as described above.

As shown in FIG. 12, the learning device 100
When performing federated learning in which multiple client devices are made to learn the same model,
Assigning each of the plurality of client devices to perform one of at least two or more different learning methods set in advance (step S101);
Counting the models generated after learning by the multiple client devices (step S102);
The following process is executed.

The present invention, configured as described above, performs associative learning in which multiple client devices each perform learning using a different learning method, and then aggregates the models after learning. This allows the characteristics of the different learning methods to be reflected in the model, making it possible to generate high-quality models and suppressing the increase in calculation time caused by associative learning.

The above-mentioned program can be stored and supplied to a computer using various types of non-transitory computer readable media. Non-transitory computer readable media include various types of tangible storage media. Examples of non-transitory computer readable media include magnetic recording media (e.g., flexible disks, magnetic tapes, hard disk drives), magneto-optical recording media (e.g., magneto-optical disks), CD-ROMs (Read Only Memory), CD-Rs, CD-R/Ws, and semiconductor memories (e.g., mask ROMs, PROMs (Programmable ROMs), EPROMs (Erasable PROMs), flash ROMs, and RAMs (Random Access Memory)). The program may also be supplied to a computer by various types of transitory computer readable media. Examples of transitory computer readable media include electrical signals, optical signals, and electromagnetic waves. The transitory computer readable media can supply the program to a computer via wired communication paths such as electric wires and optical fibers, or wireless communication paths.

Although the present invention has been described above with reference to the above-mentioned embodiments, the present invention is not limited to the above-mentioned embodiments. Various modifications that can be understood by a person skilled in the art can be made to the configuration and details of the present invention within the scope of the present invention. Furthermore, at least one or more of the functions of the above-mentioned allocation unit 121 and aggregation unit 122 may be executed by an information processing device installed and connected anywhere on the network, that is, they may be executed by so-called cloud computing.

<Additional Notes>
A part or all of the above-described embodiments can be described as follows: The following is an outline of the configurations of the learning method, learning device, and program of the present invention. However, the present invention is not limited to the following configurations.
(Appendix 1)
A learning method using federated learning in which a plurality of client devices execute learning for the same model, comprising:
assigning each of the plurality of client devices to perform learning using at least two or more different learning methods that have been set in advance;
aggregating the models generated after training by the plurality of client devices;
How to learn.
(Appendix 2)
2. The learning method according to claim 1, further comprising:
causing at least one predetermined client device to execute a first learning, and assigning at least one other of the client devices to execute a second learning, the second learning being a learning method different from that of the first learning and involving a process of generating learning data;
How to learn.
(Appendix 3)
3. The learning method according to claim 2, further comprising:
assigning the predetermined client device to perform normal learning as the first learning, and the other client devices to perform adversarial learning involving generating adversarial samples and learning processing of the adversarial samples as the second learning;
How to learn.
(Appendix 4)
A learning method according to any one of claims 1 to 3,
aggregating the models generated after the learning is performed by the multiple client devices to generate a new model;
Furthermore, the method assigns the client devices to perform learning of the new model using at least two or more different learning methods that are set in advance.
How to learn.
(Appendix 5)
A learning method according to any one of claims 1 to 4,
assigning the plurality of client devices to execute one of the learning methods according to an allocation ratio of at least two preset learning methods;
How to learn.
(Appendix 6)
6. The learning method according to claim 5, further comprising:
aggregating models generated after the execution of learning by the multiple client devices, and then changing the allocation ratio;
and allocating the plurality of client devices to execute any one of the learning processes in accordance with the changed allocation ratio.
How to learn.
(Appendix 7)
7. The learning method according to claim 6, further comprising:
changing the allocation ratio based on a progress of learning executed by the plurality of client devices;
How to learn.
(Appendix 8)
The learning method according to claim 6 or 7,
changing the allocation ratio based on a model aggregated from a plurality of the client devices;
How to learn.
(Appendix 9)
9. The learning method according to claim 8, further comprising:
changing the allocation ratio based on a result of evaluating the performance of the model aggregated from the plurality of client devices;
How to learn.
(Appendix 10)
A learning device using federated learning that causes multiple client devices to learn the same model,
an allocation unit that allocates, to each of the plurality of client devices, learning to be performed using one of at least two or more different learning methods that are set in advance;
A counting unit that counts models generated after learning by the multiple client devices;
A learning device equipped with
(Appendix 11)
11. The learning device according to claim 10,
the allocation unit causes at least one predetermined client device to execute a first learning, and allocates at least one other of the client devices to execute a second learning, the second learning being a learning method different from that of the first learning and involving a process of generating learning data;
Learning device.
(Appendix 12)
12. The learning device according to claim 11,
The allocation unit causes the predetermined client device to perform normal learning as the first learning, and assigns the other client devices to perform adversarial learning involving generating adversarial samples and learning processing of the adversarial samples as the second learning.
Learning device.
(Appendix 13)
13. The learning device according to any one of claims 10 to 12,
The aggregation unit aggregates models generated after the execution of learning by the multiple client devices to generate a new model;
The allocation unit further allocates the client devices to execute learning of the new model using at least two or more different learning methods that are set in advance.
Learning device.
(Appendix 14)
14. The learning device according to any one of claims 10 to 13,
the allocating unit allocates the plurality of client devices to execute one of the learning methods in accordance with an allocation ratio of at least two preset learning methods;
Learning device.
(Appendix 15)
15. The learning device according to claim 14,
a change unit that changes the allocation ratio after aggregating models generated after execution of learning by the plurality of client devices;
The allocation unit further allocates the plurality of client devices to execute any one of the learning operations in accordance with the changed allocation ratio.
Learning device.
(Appendix 16)
16. The learning device according to claim 15,
the change unit changes the allocation ratio based on a progress of learning executed by the plurality of client devices.
Learning device.
(Appendix 17)
17. The learning device according to claim 15,
the change unit changes the allocation ratio based on a model aggregated from the plurality of client devices.
Learning device.
(Appendix 18)
18. The learning device according to claim 17,
the change unit changes the allocation ratio based on a result of evaluating the performance of the model aggregated from the plurality of client devices.
Learning device.
(Appendix 19)
In the information processing device,
When performing federated learning in which a plurality of client devices are made to perform learning on the same model, each of the plurality of client devices is assigned to perform one of learning methods using at least two or more different learning methods that are set in advance;
aggregating the models generated after training by the plurality of client devices;
A computer-readable storage medium that stores a program for executing processing.

10 Central server 11 Client communication device 12 Model tallying device 13 Client allocation device 14 Client ratio adjustment device 15 Input device 20-1 to 20-K Client 50 Central server 51 Client communication device 52 Model tallying devices 60-1 to 60-K Client 100 Learning device 101 CPU
102 ROM
103 RAM
104 Program group 105 Storage device 106 Drive device 107 Communication interface 108 Input/output interface 109 Bus 110 Storage medium 111 Communication network 121 Allocation unit 122 Counting unit 200 Client device

Claims (10)

A learning method using federated learning in which an information processing device causes a plurality of client devices to execute learning for a same model, comprising:
The information processing device,
assigning each of the plurality of client devices to perform learning using at least two or more different learning methods that have been set in advance;
aggregating the models generated after training by the plurality of client devices;
How to learn. The learning method according to claim 1 ,
causing at least one predetermined client device to execute a first learning, and assigning at least one other of the client devices to execute a second learning, the second learning being a learning method different from that of the first learning and involving a process of generating learning data;
How to learn. The learning method according to claim 2,
assigning the predetermined client device to perform normal learning as the first learning, and the other client devices to perform adversarial learning involving generating adversarial samples and learning processing of the adversarial samples as the second learning;
How to learn. A learning method according to any one of claims 1 to 3,
aggregating the models generated after the learning is performed by the multiple client devices to generate a new model;
Furthermore, the method assigns the client devices to perform learning of the new model using at least two or more different learning methods that are set in advance.
How to learn. A learning method according to any one of claims 1 to 4,
assigning the plurality of client devices to execute one of the learning methods according to an allocation ratio of at least two preset learning methods;
How to learn. The learning method according to claim 5,
aggregating models generated after the execution of learning by the multiple client devices, and then changing the allocation ratio;
and allocating the plurality of client devices to execute any one of the learning processes in accordance with the changed allocation ratio.
How to learn. The learning method according to claim 6,
changing the allocation ratio based on a progress of learning executed by the plurality of client devices;
How to learn. A learning method according to claim 6 or 7, comprising:
changing the allocation ratio based on a model aggregated from a plurality of the client devices;
How to learn. A learning device using federated learning that causes multiple client devices to learn the same model,
an allocation unit that allocates, to each of the plurality of client devices, learning to be performed using one of at least two or more different learning methods that are set in advance;
A counting unit that counts models generated after learning by the multiple client devices;
A learning device equipped with In the information processing device,
When performing federated learning in which a plurality of client devices are made to perform learning on the same model, each of the plurality of client devices is assigned to perform one of learning methods using at least two or more different learning methods that are set in advance;
aggregating the models generated after training by the plurality of client devices;
A program for executing a process.

Images