Method for training learning device and computing device for performing same

Abstract

A method according to one embodiment of the disclosure, performed in a computing device including one or more processors and a memory storing one or more programs executed by the one or more processors, comprises the steps of: inputting input data of a predetermined domain into a machine learning model and outputting feature data representing properties of the machine learning model; transmitting the feature data to a domain classification device; receiving, from the domain classification device, a domain source prediction value corresponding to the feature data; and training the machine learning model using a first loss function that increases a difference between the domain source prediction value and a ground-truth domain value of the feature data.

Description

Method for training a learning device and a computing device for performing the same

[0001] An embodiment of the present invention relates to a method for training a learning device.

[0002]

[0003] In the field of cloud computing, as the domain environments in which computing devices operate become more diverse, it is becoming important for computing devices in different domains to be trained to produce consistent results.

[0004] In an exemplary embodiment, a cluster (a set of computing devices that process data of a domain) of a specific domain (e.g., Google) can analyze only the data input into that domain. When the domain cluster analyzes time-series data regarding a workload, the domain cluster can predict the workload for times that have not yet arrived. In this case, Google's domain cluster and Alibaba's domain cluster may be trained with different characteristics. Accordingly, even when the same new input value is input, the clusters of both domains may derive different prediction results. To prevent this, a technology is required that can train both domain clusters universally.

[0005] Recently, knowledge distillation techniques utilizing teacher-student models have been employed to train neural networks on different learning devices. However, these techniques have limitations in that they only enable a unidirectional flow of knowledge, transferring knowledge from the teacher model to the student model, and fail to efficiently transmit the teacher model's knowledge.

[0006] To overcome these limitations, a technology is required to universally train two or more learning models running in different domain environments together to produce the same results.

[0007]

[0008] The objective of the present invention is to provide a method for training a learning device capable of universally training two or more learning models running in different domain environments to produce the same result, and a computing device for performing the same.

[0009] The objectives of the present invention are not limited to those mentioned above, and other objectives and advantages of this specification not mentioned may be understood from the following description and will be more clearly understood from the embodiments of this specification. Furthermore, it will be readily apparent that the objectives and advantages of this specification can be realized by the means and combinations thereof set forth in the claims.

[0010]

[0011] A method according to one disclosed embodiment is performed in a computing device comprising one or more processors and a memory storing one or more programs executed by said one or more processors, and comprises the steps of inputting input data of a predetermined domain into a machine learning model and outputting characteristic data representing the attributes of said machine learning model; transmitting said characteristic data to a domain classification device; receiving a domain source prediction value corresponding to said characteristic data from said domain classification device; and training said machine learning model by a first loss function that increases the difference between said domain source prediction value and the domain correct value of said characteristic data.

[0012] The step of outputting the above feature data may include the step of generating a plurality of embedding vectors from the input data of the computing device and the step of producing feature data by applying an attention mechanism to the plurality of embedding vectors.

[0013] The step of applying the above attention mechanism may include the step of calculating the weight of each of the plurality of embedding vectors and the step of calculating feature data based on the weight of each of the embedding vectors.

[0014] The above weight ( ) can be calculated by the following (Mathematical Formula 1).

[0015] (Mathematical Formula 1)

[0016]

[0017] : Weights of the embedding vector

[0018] : Kernel function

[0019] : Multidimensional vector of input data (embedding vector)

[0020] The above embedding vector ( ) can be calculated by the following (Equation 2).

[0021] (Mathematical Formula 2)

[0022]

[0023] : Multidimensional vector of input data (embedding vector)

[0024] : Vector query data

[0025] : Vector's key data

[0026] : Learning parameters of an MLP (multi-layer perceptron)

[0027] The above method may further include the step of training the machine learning model according to a preset second loss function based on the input data and the plurality of embedding vectors.

[0028] A method according to one disclosed embodiment is performed in a computing device comprising one or more processors and a memory storing one or more programs executed by said one or more processors, and comprises the steps of: acquiring characteristic data representing the characteristics of a learning model executed by said learning device from said learning device; determining the source of said characteristic data and calculating a domain source prediction value; transmitting said domain source prediction value to said learning device; and controlling said learning device to learn said learning model based on a first loss function having said domain source prediction value and said correct value of said domain source as factors.

[0029] A computing device according to one disclosed embodiment is a computing device comprising one or more processors and a memory for storing one or more programs executed by the one or more processors, wherein the one or more programs include a command for inputting input data of a predetermined domain into a machine learning model and outputting feature data representing the attributes of the machine learning model, a command for transmitting the feature data to a domain classification device, a command for receiving a domain source prediction value corresponding to the feature data from the domain classification device, and a command for training the machine learning model by a first loss function that increases the difference between the domain source prediction value and the domain correct value of the feature data.

[0030]

[0031] According to one disclosed embodiment, computing devices of different domains can be trained to produce consistent results. In other words, two or more learning models running in different domain environments can be universally trained together to produce the same results.

[0032] In an exemplary embodiment, each cluster of different domains can be trained to produce the same prediction result when receiving new data.

[0033]

[0034] The present disclosure can be easily understood from the combination of the following detailed description and the accompanying drawings, where reference numerals denote structural elements.

[0035] FIG. 1 is a schematic diagram showing an environment for training a plurality of learning devices with different domains according to one embodiment.

[0036] FIG. 2 is a schematic diagram illustrating a method for training a plurality of learning devices having different domains, according to one embodiment.

[0037] FIG. 3 is a flowchart illustrating a method for training a plurality of learning devices with different domains according to one embodiment.

[0038] FIG. 4 is a diagram showing an algorithm for implementing learning by a first loss function according to one embodiment.

[0039] FIG. 5 is a flowchart illustrating a method for generating characteristic data representing the attributes of a learning device for each domain learning device according to one embodiment.

[0040] FIG. 6 is a block diagram showing the configuration of a computing device for training a plurality of learning devices with different domains, according to one embodiment.

[0041]

[0042] A method is provided for a computing device comprising one or more processors and a memory for storing one or more programs executed by said one or more processors, the method comprising the steps of: inputting input data of a predetermined domain into a machine learning model and outputting characteristic data representing the attributes of said machine learning model; transmitting said characteristic data to a domain classification device; receiving a domain source prediction value corresponding to said characteristic data from said domain classification device; and training said machine learning model by a first loss function such that the difference between said domain source prediction value and the domain correct value of said characteristic data becomes large.

[0043]

[0044] Hereinafter, specific embodiments of the present invention will be described with reference to the drawings. The following detailed description is provided to facilitate a comprehensive understanding of the methods, apparatuses, and / or systems described herein. However, this is merely illustrative and the present invention is not limited thereto.

[0045] In describing the embodiments of the present invention, detailed descriptions of known technologies related to the present invention are omitted if it is determined that such detailed descriptions may unnecessarily obscure the essence of the present invention. Furthermore, the terms described below are defined in consideration of their functions within the present invention, and these may vary depending on the intentions or practices of the user or operator. Therefore, such definitions should be based on the content throughout this specification. Terms used in the detailed description are intended merely to describe the embodiments of the present invention and should not be limiting in any way. Unless explicitly stated otherwise, expressions in the singular form include the meaning of the plural form. In this description, expressions such as "include" or "comprise" are intended to refer to certain characteristics, numbers, steps, actions, elements, parts thereof, or combinations thereof, and should not be interpreted to exclude the existence or possibility of one or more other characteristics, numbers, steps, actions, elements, parts thereof, or combinations thereof other than those described.

[0046] Additionally, terms including ordinal numbers, such as 'first' or 'second', may be used to describe various components, but said components should not be limited by said terms. Such terms may be used for the purpose of distinguishing one component from another. For example, without departing from the scope of the present invention, the first component may be named the second component, and similarly, the second component may be named the first component.

[0047] Furthermore, when it is said that one configuration is "connected" to another configuration, this includes not only cases where they are "directly connected," but also cases where they are "connected with another configuration in between."

[0048]

[0049] FIG. 1 is a schematic diagram showing an environment for training a plurality of learning devices with different domains according to one embodiment.

[0050] Referring to FIG. 1, an environment for training multiple learning devices with different domains may include two or more domain learning devices (100-1, 100-2) and a domain classification device (200). Each domain learning device (100-1, 100-2) may communicate with the domain classification device (200). At this time, each domain learning device (100-1, 100-2) may communicate with the domain classification device (200) by being connected to a communication network (50).

[0051] In an exemplary embodiment, the communication network (50) may include the Internet, one or more local area networks, wide area networks, cellular networks, mobile networks, other types of networks, or a combination of such networks.

[0052] Each of the two or more domain learning devices (100-1, 100-2) can learn from input data and, when acquiring new data, acquire output data corresponding to the learning purpose. Each domain learning device (100-1, 100-2) can be learned for the same purpose, but as each learning data and domain environment are different, the learning content and learning results of each domain learning device (100-1, 100-2) may have different characteristics.

[0053] Accordingly, even when the same new data is used as input, each domain learning device (100-1, 100-2) can output different result data. To prevent different results from being produced, each domain learning device (100-1, 100-2) can be trained to have the same properties through the operation of the domain classification device (200).

[0054] In an exemplary embodiment, each domain learning device (100-1, 100-2) may include a processor that executes a machine learning model. Each domain learning device (100-1, 100-2) may include various electronic devices capable of communicating with a domain classification device (200). For example, each domain learning device (100-1, 100-2) may include a smartphone, a tablet PC, a notebook PC, a desktop personal computer, a personal digital assistant (PDA), a wearable device such as a smart watch, an e-book reader, smart glasses, a portable game console, a navigation device, a digital camera, etc.

[0055] The domain classification device (200) can receive characteristic data corresponding to each domain learning device (100-1, 100-2). Each characteristic data may represent the properties of the corresponding domain learning device (100-1, 100-2). The domain classification device (200) may attempt to distinguish the source of the received characteristic data. Each of two or more domain learning devices (100-1, 100-2) may be trained so that the domain classification device (200) cannot distinguish the source of the characteristic data.

[0056] In an exemplary embodiment, the domain separation device (200) includes one or more processors necessary for generating data to train a machine learning model and a computer-readable recording medium connected to said processor, and may further include a database for storing data. The computer-readable recording medium may be inside or outside the processor and may be connected to the processor by various well-known means. A processor within the domain separation device (200) may cause the domain separation device (200) to operate according to the exemplary embodiments described herein. For example, the processor may execute instructions stored in the computer-readable recording medium, and the instructions stored in the computer-readable recording medium may be configured to cause the domain separation device (200) to perform operations according to the exemplary embodiments described herein when executed by the processor.

[0057]

[0058] FIG. 2 is a schematic diagram illustrating a method for training a plurality of learning devices with different domains according to one embodiment, FIG. 3 is a flowchart illustrating a method for training a plurality of learning devices with different domains according to one embodiment, and FIG. 4 is a diagram illustrating an algorithm for implementing learning by a first loss function according to one embodiment.

[0059] The method illustrated in FIGS. 2 to 4 may be performed, for example, by one or more of the aforementioned domain learning devices (100-1, 100-2) and domain classification devices (200). Additionally, the method illustrated in FIGS. 2 to 4 may be performed, for example, by the computing device (12) described later. Although the method is described in the illustrated flowchart as being divided into multiple steps, at least some of the steps may be performed in a different order, combined with other steps and performed together, omitted, divided into detailed steps, or performed with one or more steps not illustrated added.

[0060] Referring to FIGS. 2 to 4, a method for training multiple learning devices with different domains may include the step (S100) of generating characteristic data representing the attributes of a domain learning device from input data for each domain learning device, and the step (S200) of training each domain learning device so that a domain classification device cannot distinguish the source of the characteristic data received from each domain learning device.

[0061] Each domain learning device (100-1, 100-2) can execute a machine learning model. In an exemplary embodiment, the machine learning model may be a model that receives and analyzes time-series data for a specific physical quantity and predicts the physical quantity for a time that has not yet arrived. For example, the time-series data analyzed by the machine learning model may be data representing the hourly workload of a server connected to a plurality of computing devices. The workload may be the load of data processed by the server. The machine learning model may analyze the amount of hourly workload and predict the amount of workload for a specific time that has not yet arrived.

[0062] Alternatively, in an exemplary embodiment, the machine learning model may be a model that classifies input samples. The machine learning model may predict the classification results of the input samples and provide them to the user. For example, the machine learning model may receive various animal images in image format and predict which animal the image is of. Alternatively, the machine learning model may receive an X-ray image for medical diagnosis and predict which disease the X-ray image contains.

[0063] The above embodiments are merely examples, and machine learning models are not limited to the above embodiments and may perform learning for other purposes.

[0064] A machine learning model may include a neural network structure formed of multiple neurons and layers. The neural network may include one or more layers that perform pre-configured functions. Each of the one or more layers may include multiple neurons that serve as the minimum unit for processing input data.

[0065] In step S100, each domain learning device (100-1, 100-2) can generate feature data representing the attributes of the domain learning device (100-1, 100-2) from the input data. The specific details are as follows. The domain learning device (100) can acquire input data. The domain learning device (100) can acquire feature data representing the properties of the corresponding domain learning device by inputting the input data into a machine learning model neural network. Specifically, the domain learning device (100) can produce feature data by processing the input data by passing it through a plurality of layers constituting the neural network. A more specific explanation regarding the acquisition of feature data will be described later through FIGS. 2 and FIGS. 5. Each domain learning device (100-1, 100-2) can transmit the respective feature data to the domain classification device (200).

[0066] In step S200, each domain learning device (100-1, 100-2) can be learned by a first loss function so that the domain classification device (200) cannot distinguish the source of the feature data received from each domain learning device (100-1, 100-2). (Ordinal expressions such as "first" are expressed in the order mentioned in the description, and what the name refers to may be determined by the content throughout the specification and may be displayed differently from the ordinals of the claims.) In an exemplary embodiment, the domain learning device (100) can perform learning by the first loss function through the algorithm of FIG. 4.

[0067] The specific details are as follows. The domain classification device (200) can receive feature data from each domain learning device (100-1, 100-2). The transmitted feature data may represent properties regarding the learning of the source domain learning device (100-1 or 100-2). The domain classification device (200) can infer which domain learning device (100-1 or 100-2) the received feature data was received from. That is, the domain classification device (200) can determine the source of the input feature data. The domain classification device (200) can transmit the predicted source of the feature data to the domain classification device (100).

[0068] The learning models of each domain learning device (100-1, 100-2) can be trained so that the domain classification device (200) cannot correctly classify the source of the feature data. In an exemplary embodiment, the domain learning device (100) can compare the predicted value of the feature data source received from the domain classification device (200) with the correct value for the source of the feature data. The domain learning device (100) can train the machine learning model so that the difference between the predicted value of the feature data source and the correct value of the feature data source increases.

[0069] The domain classification device (200) can adjust the neural network of the learning model executed by each domain learning device (100-1, 100-2) so that the source of the first feature data received from the first domain learning device (100-1) is determined to be the second domain learning device (100-2).

[0070] Specifically, the domain classification device (200) can calculate a first loss function value that produces a smaller value as the inference of the source of the characteristic data differs from the actual source. The first loss function may be a function that includes the predicted source of the characteristic data (hereinafter, domain source prediction value) and the actual source (hereinafter, domain source correct value) as arguments. The first loss function may be a function that has a smaller result value as the difference between the domain source prediction value and the domain source correct value increases. In an exemplary embodiment, the first loss function may produce a smaller result value as the domain source prediction value differs from the domain source prediction value.

[0071] The domain classification device (200) can change the parameters of the neurons in each layer constituting the machine learning neural network of the domain learning device (100) so that the value of the first loss function becomes smaller, thereby producing feature data in which the source cannot be distinguished. The learning performed by each domain learning device (100) will be explained in more detail below through FIG. 5.

[0072]

[0073] According to one disclosed embodiment, computing devices of different domains can be trained to produce consistent results. In other words, two or more learning models running in different domain environments can be universally trained together to produce the same results.

[0074] In an exemplary embodiment, each cluster of different domains can be trained to produce the same prediction result when receiving new data.

[0075]

[0076] FIG. 5 is a flowchart illustrating a method for generating characteristic data representing the attributes of a learning device for each domain learning device according to one embodiment. The method illustrated in FIG. 5 may be performed, for example, by one or more of the aforementioned domain learning devices (100-1, 100-2) and domain classification devices (200). Additionally, the method illustrated in FIG. 5 may be performed, for example, by the computing device (12) described later. Although the method is described in the illustrated flowchart by dividing it into a plurality of steps, at least some of the steps may be performed in a different order, combined with other steps and performed together, omitted, divided into detailed steps, or performed with one or more steps not illustrated added.

[0077] Referring to FIGS. 2 and FIGS. 5, the step (S100) of each domain learning device generating feature data may include the step (S110) of each domain learning device generating an embedding vector corresponding to each of a plurality of samples included in the input data, and the step (S120) of generating feature data by applying an attention mechanism to the plurality of embedding vectors.

[0078] In step S110, each domain learning device (100-1, 100-2) can generate an embedding vector corresponding to each of the multiple samples included in the input data. The specific details are as follows. The domain learning device (100) can receive data to be learned (hereinafter, input data). The input data may consist of multiple samples.

[0079] In an exemplary embodiment, the input data may be time-series data for a specific physical quantity, and each of the plurality of samples may be a portion of the time-series data divided over time. In another exemplary embodiment, the input data may be a plurality of animal images, and each of the plurality of samples may be a single animal image. The above embodiments are merely examples, and the domain learning device (100) is not limited to the above embodiments and may receive data for other purposes.

[0080] The domain learning device (100) can generate an embedding vector corresponding to each sample by passing multiple samples through the embedding layer of a neural network.

[0081] Additionally, at step S112, each domain learning device (100-1, 100-2) can train a machine learning model by a second loss function based on the generated embedding vector and input data. (Ordinal expressions such as "first" are expressed in the order mentioned in the description, and what the name refers to may be determined by the content throughout the specification and may be indicated differently from the ordinals of the claims.) For example, the domain learning device (100) can perform one or more of supervised learning, unsupervised learning, reinforcement learning, semi-supervised learning, self-supervised learning, contrastive learning, meta learning, and transfer learning on the machine learning model.

[0082] In an exemplary embodiment, the domain learning device (100) can perform supervised learning on a machine learning neural network. A specific description of the domain learning device (100) performing supervised learning is as follows. The domain learning device (100) can calculate a predicted value according to a pre-set objective based on an embedding vector from input data. The domain learning device (100) can calculate a second loss function value representing the difference between the predicted value and the correct value by comparing the correct value and the predicted value included in the input data. The domain learning device (100) can adjust the machine learning neural network (including an embedding layer and a hidden layer) that calculates the embedding vector and the predicted value so that the second loss function value is reduced.

[0083] In an exemplary embodiment, a pre-set objective is to predict the amount of workload at a specific time, the predicted value is the predicted amount of workload at a specific time, and the correct value may be the actual amount of workload at a specific time. Additionally, in an exemplary embodiment, a pre-set objective is to classify an animal appearing in an animal image, the predicted value is the type of the predicted animal, and the correct value may be the type of the actual animal.

[0084] A domain learning device (100) can be trained such that a total loss function based on a first loss function and a second loss function is minimized. Minimizing the total loss function may mean that the accuracy of the training of each domain learning device increases and that the training of the two domain learning devices produces consistent results. In an exemplary embodiment, the total loss function (LOSS T ) may be equal to the following [Mathematical Formula 1]. (Ordinal expressions such as "1" are expressed in the order mentioned in the description; the formula referred to by the said mathematical formula may be determined by the content throughout the specification and may be indicated differently from the ordinal number of the claim.)

[0085] [Mathematical Formula 1]

[0086]

[0087] : Classification of domain separation devices

[0088] : Weights for the loss of domain source classification

[0089] : Loss for individual learning of each domain learning device

[0090] : Predicted loss of domain source classification

[0091] In step S120, each domain learning device (100-1, 100-2) can generate feature data by applying an attention mechanism to a plurality of embedding vectors. The specific details are as follows.

[0092] The domain learning device (100) can generate an embedding vector corresponding to each embedding vector by passing a plurality of embedding vectors generated in an embedding layer through an attention layer. The domain learning device (100) can generate feature data that emphasizes only the core features of the input data by assigning weights (attention scores) to important elements of each embedding vector. Each of the first domain learning device (100-1) and the second domain learning device (100-2) can transmit the feature data to the domain classification device (200).

[0093] In an exemplary embodiment, the domain learning device (100) can calculate the weight (attention score) of each embedding vector through the following [Equation 2].

[0094] [Mathematical Formula 2]

[0095]

[0096] : Weights of the embedding vector

[0097] : Kernel function

[0098] : Multidimensional vector of input data (embedding vector)

[0099] In this case, the kernel function may be a positive semi-definite kernel function.

[0100] At this time, the embedding vector of [Equation 2] ( ) can be calculated through [Equation 3].

[0101] [Mathematical Formula 3]

[0102]

[0103] : Multidimensional vector of input data (embedding vector)

[0104] : Vector query data

[0105] : Vector's key data

[0106] : Learning parameters of an MLP (multi-layer perceptron)

[0107]

[0108] FIG. 6 is a block diagram illustrating the configuration of a computing device for training a plurality of learning devices having different domains, according to one embodiment. In the illustrated embodiment, each component may have different functions and capabilities in addition to those described below, and may include additional components in addition to those described below.

[0109] The illustrated computing environment (10) includes a computing device (12). In one embodiment, the computing device (12) may be each of the aforementioned domain learning devices (100-1, 100-2) and may perform the role of each of the domain learning devices (100-1, 100-2) in a method of training multiple learning devices with different domains as described in FIGS. 1 to 5.

[0110] In addition, in one embodiment, the computing device (12) may be the aforementioned domain classification device (200) and may perform the role of the domain classification device (200) in a method of training a plurality of learning devices with different domains as described in FIGS. 1 to 5.

[0111] The computing device (12) includes at least one processor (14), a computer-readable storage medium (16), and a communication bus (18). The processor (14) can cause the computing device (12) to operate according to the exemplary embodiment described above. For example, the processor (14) can execute one or more programs stored in the computer-readable storage medium (16). The one or more programs may include one or more computer-executable instructions, and the computer-executable instructions may be configured to cause the computing device (12) to perform operations according to the exemplary embodiment when executed by the processor (14).

[0112] A computer-readable storage medium (16) is configured to store computer-executable instructions or program code, program data and / or other suitable forms of information. A program (20) stored in the computer-readable storage medium (16) includes a set of instructions executable by a processor (14). In one embodiment, the computer-readable storage medium (16) may be memory (volatile memory such as random access memory, non-volatile memory, or a suitable combination thereof), one or more magnetic disk storage devices, optical disk storage devices, flash memory devices, other forms of storage media that are accessed by a computing device (12) and capable of storing desired information, or a suitable combination thereof.

[0113] The communication bus (18) interconnects various other components of the computing device (12), including the processor (14) and the computer-readable storage medium (16).

[0114] The computing device (12) may also include one or more input / output interfaces (22) and one or more network communication interfaces (26) that provide interfaces for one or more input / output devices (24). The input / output interfaces (22) and network communication interfaces (26) are connected to a communication bus (18). The input / output devices (24) may be connected to other components of the computing device (12) through the input / output interfaces (22). An exemplary input / output device (24) may include an input device such as a pointing device (such as a mouse or trackpad), a keyboard, a touch input device (such as a touchpad or touchscreen), a voice or sound input device, various types of sensor devices and / or imaging devices, and / or an output device such as a display device, a printer, a speaker and / or a network card. An exemplary input / output device (24) may be included inside the computing device (12) as a component constituting the computing device (12), or it may be connected to the computing device (12) as a separate device distinct from the computing device (12).

[0115]

[0116] Although representative embodiments of the present invention have been described in detail above, those skilled in the art will understand that various modifications can be made to the above-described embodiments without departing from the scope of the present invention. Therefore, the scope of the present invention should not be limited to the described embodiments, but should be defined by the claims set forth below as well as equivalents thereof.

Claims

1. One or more processors; and A method performed in a computing device comprising memory for storing one or more programs executed by one or more processors, wherein A step of inputting input data of a predetermined domain into a machine learning model and outputting feature data representing the attributes of the machine learning model; The step of transmitting the above characteristic data to a domain classification device; and A step of receiving a domain source prediction value corresponding to the characteristic data from the domain classification device; A method comprising the step of training the machine learning model by a first loss function that increases the difference between the domain source prediction value and the domain correct value of the feature data.

2. In Claim 1, The step of outputting the above characteristic data is, A step of generating a plurality of embedding vectors from input data of the computing device; and A method comprising the step of producing feature data by applying an attention mechanism to the plurality of embedding vectors.

3. In Claim 2, The step of applying the above attention mechanism is, A step of calculating the weight of each of the plurality of embedding vectors; and A method comprising the step of calculating feature data based on the weight of each of the above-mentioned embedding vectors.

4. In Claim 3, The above weight ( )Is, A method calculated by the following (Mathematical Formula 1). (Mathematical Formula 1) : Weights of the embedding vector : Kernel function : Multidimensional vector of input data (embedding vector) 5. In Claim 4, The above embedding vector ( )Is, A method calculated by the following (Mathematical Formula 2). (Mathematical Formula 2) : Multidimensional vector of input data (embedding vector) : Vector query data : Vector's key data : Learning parameters of an MLP (multi-layer perceptron) 6. In Claim 2, The above method is, A method further comprising the step of training the machine learning model according to a pre-set second loss function based on the input data and the plurality of embedding vectors.

7. One or more processors; and A method performed in a computing device comprising memory for storing one or more programs executed by one or more processors, wherein A step of obtaining characteristic data representing the characteristics of a learning model executed by each of two or more learning devices from each of the said learning devices; A step of determining the source of the above characteristic data and calculating a domain source prediction value; The step of transmitting the above domain source prediction value to each of the two or more learning devices; and A method comprising the step of controlling each of the two or more learning devices to train the learning model based on a first loss function having the domain source prediction value and the domain source correct answer value as arguments.

8. In Claim 7, The above first loss function is, A method, wherein the difference between the predicted value of the domain source and the correct value of the domain source is greater, the output value of the first loss function is set to be smaller.

9. In Claim 7, The above first loss function is, A method, wherein the function is configured such that the output value of the first loss function becomes smaller when the predicted value of the domain source and the correct value of the domain source are determined to be different.

10. One or more processors; and A computing device comprising memory for storing one or more programs executed by the above-mentioned one or more processors, One or more of the above programs are, A command for inputting input data of a predetermined domain into a machine learning model and outputting feature data representing the attributes of the machine learning model; A command for transmitting the above characteristic data to a domain classification device; and A command for receiving a domain source prediction value corresponding to the characteristic data from the domain classification device; A computing device comprising instructions for training the machine learning model by a first loss function that increases the difference between the domain source prediction value and the domain correct value of the feature data.

11. In Claim 10, The command for outputting the above characteristic data is, A command for generating a plurality of embedding vectors from input data of the above computing device; and A computing device comprising a command for producing feature data by applying an attention mechanism to the above plurality of embedding vectors.

12. In Claim 11, The command for applying the above attention mechanism is, A command for calculating the weight of each of the plurality of embedding vectors above; and A computing device comprising a command for calculating feature data based on the weight of each of the above-mentioned embedding vectors.

13. In Claim 12, The above weight ( )Is, A computing device calculated by the following (Mathematical Formula 1). (Mathematical Formula 1) : Weights of the embedding vector : Kernel function : Multidimensional vector of input data (embedding vector) 14. In Claim 4, The above embedding vector ( )Is, A computing device calculated by the following (mathematical formula 2). (Mathematical Formula 2) : Multidimensional vector of input data (embedding vector) : Vector query data : Vector's key data : Learning parameters of an MLP (multi-layer perceptron) 15. In Claim 11, One or more of the above programs are, A method further comprising instructions for training the machine learning model according to a preset second loss function based on the input data and the plurality of embedding vectors.

Images