Resource-based federated learning method, and local device and server for performing same

Abstract

Disclosed are a resource-based federated learning method, and a local device and server for performing same. The resource-based federated learning method comprises the steps of: determining the size of a personalization model parameter to be applied to a personalization model of a local device, on the basis of hardware information of the local device or the size of a pre-stored dataset; applying the personalization model parameter of the determined size to the personalization model, and training a local model of the local device by using the personalization model; transmitting, to a global server, a local parameter for the weight of a neural network included in the local model, and receiving, from the global server, a global parameter derived on the basis of the local parameter; and applying the global parameter to the local model, and deriving an output value for new user data by using the local model.

Description

Resource-based federated learning method and local devices and servers that perform it

[0001] The present invention relates to a resource-based federated learning method and to a local device and server performing the method. Specifically, the present invention relates to a method for performing federated learning using a personalized model with variable parameter sizes based on resource information of the local device, and detecting anomalies in user data generated by the local device using the federated-learned local model.

[0002]

[0003] The content described in this section merely provides background information for the present embodiment and does not constitute prior art.

[0004] As financial institutions and electronic finance companies provide financial products and services through computing devices, non-face-to-face financial transactions, where users process financial services online without directly interacting with financial institution or electronic finance company employees, are on the rise. As non-face-to-face financial transactions increase, the importance of technologies that accurately detect forgery or fraudulent transactions online is growing.

[0005] Meanwhile, with the recent advancements in AI and machine learning technologies, technologies capable of detecting forgery and tampering in real time are being developed. Specifically, these technologies train machine learning models on normal patterns, and then, when new patterns emerge that deviate from the normal patterns, determine whether the data is abnormal.

[0006] Traditionally, machine learning has often been implemented using a centralized learning approach. This approach requires significant resources, so local data generated on each local device is often sent to a server, where the model is trained. This process, however, poses a security risk to users' personal information. Therefore, federated learning, which trains a model to perform highly accurate anomaly detection without sharing local data generated on the local device with the server, is emerging as an alternative.

[0007] However, in the case of federated learning, there was a problem of data heterogeneity due to the use of local data with different data sizes and distributions for each user. In addition, there was a problem that some local data could be lost during the process of deriving global parameters that were commonly transmitted to multiple user devices. Furthermore, because the hardware performance of each local device differed, the operating resources of certain local devices could become insufficient during the federated learning process.

[0008]

[0009] The purpose of the present invention is to provide a resource-based federated learning method capable of increasing the efficiency of federated learning and the accuracy of anomaly detection by determining the size of personalized model parameters to be applied to a personalized model of a local device based on hardware information of the local device or the size of a pre-stored dataset, and performing federated learning on a local model using a personalized model to which the sized personalized model parameters are applied.

[0010] In addition, an object of the present invention is to provide a federated learning method capable of increasing the accuracy of anomaly detection while maintaining the load applied to a local device at an appropriate level during the learning process by adjusting the size of a global model parameter applied to a personalized model based on resource information of the local device.

[0011] In addition, an object of the present invention is to provide a resource-based federated learning method that can enhance privacy protection for users by not sharing data related to personal information generated in a local device with other local devices or servers.

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

[0013]

[0014] A resource-based federated learning method according to some embodiments of the present invention includes a step of determining a size of a personalized model parameter to be applied to a personalized model of a local device based on hardware information of the local device or a size of a pre-stored dataset, a step of applying the personalized model parameter of the determined size to the personalized model and training a local model of the local device using the personalized model, a step of transmitting a local parameter for a weight of a neural network included in the local model to the global server and receiving a global parameter derived based on the local parameter from the global server, and a step of applying the global parameter to the local model and deriving an output value for new user data using the local model.

[0015] In addition, the personalized model includes an input layer, an output layer, and at least one hidden layer disposed between the input layer and the output layer, and the size of the at least one hidden layer can be varied depending on hardware information of the local device or the size of a pre-stored dataset.

[0016] In addition, the personalized model parameters may include those derived using a predetermined function based on the size of a dataset pre-stored in the local device, or those derived using a predetermined function based on performance indicators of the local device derived based on the hardware information.

[0017] Additionally, the size of the dataset may be determined by the number of users or financial data related to table data pre-stored in a database linked to the local device, and the performance indicator of the local device may be determined by the amount of computation that the local device can process per unit time.

[0018] In addition, the step of training the local model may include a step of applying user data to the local model and receiving a first vector value as an output of the local model, a step of applying the first vector value to a first personalized model and calculating a first loss value based on the first output value which is an output of the first personalized model, a step of generating augmented data for the user data and applying the same to the local model and receiving a second vector value as an output of the local model, a step of applying a synthetic vector calculated based on the second vector value and the feature vector to the second personalized model and calculating a second loss value based on the second output value which is an output of the second personalized model, and a step of training the local model using the calculated first loss value and the second loss value.

[0019] In addition, the first personalization model and the second personalization model include an input layer, an output layer, and at least one hidden layer disposed between the input layer and the output layer, and in at least one of the first personalization model and the second personalization model, the personalization model parameter having the determined size can be applied to the at least one hidden layer.

[0020] Additionally, the user data may include image or financial transaction data related to the user collected through the local device, and the augmented data may include data that rotates the user data or transforms a portion of the user data.

[0021] Additionally, the feature vector may include a vector value output from the pre-learned model by inputting public data into the pre-learned model.

[0022] In addition, the step of deriving an output value for the new user data may include a step of applying the new user data to the local model to which the global parameter is applied and receiving a first vector value as an output of the local model, a step of applying the first vector value to the first personalized model and receiving a first output value as an output of the first personalized model, and a step of applying the first output value to an anomaly detection module and determining whether the new user data is abnormal based on an output of the anomaly detection module.

[0023] In addition, the step of training the local model may include a step of applying user data to the local model and receiving a first vector value as an output of the local model, a step of calculating a first loss value based on the first vector value, a step of generating augmented data for the user data and applying the same to the local model and receiving a second vector value as an output of the local model, a step of applying a synthetic vector calculated based on the second vector value and the feature vector to the personalized model and calculating a second loss value based on a second output value which is an output of the second personalized model, and a step of training the local model using the calculated first loss value and the second loss value.

[0024] In addition, the personalized model includes an input layer, an output layer, and at least one hidden layer disposed between the input layer and the output layer, and in the personalized model, the personalized model parameter having the determined size can be applied to the at least one hidden layer.

[0025] In addition, the step of deriving an output value for the new user data may include a step of applying the new user data to the local model to which the global parameter is applied, receiving a first vector value as an output of the local model, and a step of applying the first vector value to an anomaly detection module and determining whether the new user data is abnormal based on an output of the anomaly detection module.

[0026] Meanwhile, a resource-based federated learning method according to some other embodiments of the present invention includes a step of determining and transmitting the size of each personalized model parameter for a plurality of local devices based on hardware information of the plurality of local devices or the size of a pre-stored dataset, a step of receiving, from each of the plurality of local devices, local parameters of a local model learned in each of the local devices using a personalized model to which the personalized model parameters are applied, a step of deriving global parameters based on the plurality of local parameters received from the plurality of local devices, a step of transmitting the derived global parameters to each of the plurality of local devices, and a step of receiving an output value of a local model to which the global parameters are applied from a specific local device and detecting, based on the output value, whether there is an abnormality in new user data generated in the specific local device.

[0027] Additionally, the step of determining and transmitting the size of the personalized model parameter may be determined by comparing the sizes of datasets for the plurality of local devices or performance indicators derived based on hardware information of the plurality of local devices.

[0028] In addition, the size of the dataset is determined by the number of financial data related to table data pre-stored in a database linked to the local device, the performance indicator of the local device is determined by the amount of computation that the local device can process per unit time, and the size of the personalized model parameter can be determined to be proportional to the number of financial data or the amount of computation for the plurality of local devices.

[0029] In addition, the step of determining and transmitting the size of the personalized model parameter may include a step of determining the size of the personalized model parameter using a predetermined function based on the size of a dataset pre-stored in the local device, or a step of determining the size of the personalized model parameter using a predetermined function based on a performance indicator of the local device derived based on the hardware information.

[0030] In addition, the step of performing the above abnormality detection may include a step of comparing the output value with a predetermined reference value and, if a predetermined condition is satisfied, controlling the specific local device to provide a service corresponding to the new user data.

[0031] According to some embodiments of the present invention, a local device includes a processor, a memory for loading a computer program executed by the processor, and an interface for exchanging data generated during the execution of the computer program with a global server, wherein the computer program comprises: a step of determining a size of a personalized model parameter to be applied to a personalized model of the local device based on hardware information of the local device or a size of a pre-stored dataset; a step of applying the personalized model parameter of the determined size to the personalized model and training a local model of the local device using the personalized model; a step of transmitting a local parameter for a weight of a neural network included in the local model to the global server and receiving a global parameter derived based on the local parameter from the global server; and a step of applying the global parameter to the local model and deriving an output value for new user data using the local model.

[0032] In addition, the personalized model includes an input layer, an output layer, and at least one hidden layer disposed between the input layer and the output layer, and the size of the at least one hidden layer can be varied depending on hardware information of the local device or the size of a pre-stored dataset.

[0033] Meanwhile, a server according to some embodiments of the present invention includes a processor, a memory for loading a computer program executed by the processor, and an interface for exchanging data generated during the execution of the computer program with a plurality of local devices, wherein the computer program comprises: a step of determining and transmitting the size of each personalized model parameter for each of the plurality of local devices based on hardware information of the plurality of local devices or the size of a pre-stored dataset; a step of receiving, from each of the plurality of local devices, local parameters of a local model learned in each of the local devices using a personalized model to which the personalized model parameters have been applied; a step of deriving global parameters based on the plurality of local parameters received from the plurality of local devices; a step of transmitting the derived global parameters to each of the plurality of local devices; and a step of receiving an output value of a local model to which the global parameters have been applied from a specific local device and detecting, based on the output value, whether there is an abnormality in new user data generated in the specific local device.

[0034]

[0035] The resource-based federated learning method of the present invention determines the size of personalized model parameters to be applied to a personalized model of a local device based on hardware information of each local device or the size of a pre-stored dataset, and performs federated learning of a local model using a personalized model with adjusted parameter sizes, thereby increasing the efficiency of federated learning and the accuracy of anomaly detection.

[0036] In addition, the present invention utilizes a personalized model whose parameter size is adjusted according to resources, and performs federated learning that shares only weights for multiple local models included in each local device, thereby minimizing performance degradation due to data heterogeneity that occurs when multiple local data are used, and preventing performance degradation due to differences in the size and distribution of local data.

[0037] Furthermore, the present invention can improve the learning performance of a federated learning module without sharing local data related to personal information generated on a local device with other local devices or servers. This allows the present invention to enhance user privacy while also improving the accuracy of anomaly detection.

[0038] Furthermore, the present invention can maintain the load applied to the local device during the learning process at an appropriate level by adjusting the size of the personalized model parameters applied to the personalized model based on resource information from the local device. This allows the present invention to minimize the load applied to the local device during the local model learning process while simultaneously increasing the accuracy of anomaly detection.

[0039] In addition to the above-described contents, the specific effects of the present invention are described together with the specific matters for carrying out the invention below.

[0040]

[0041] FIG. 1 is a conceptual diagram illustrating a federated learning system according to some embodiments of the present invention.

[0042] FIG. 2 is a block diagram illustrating components for a local device according to some embodiments of the present invention.

[0043] FIG. 3 is a flowchart illustrating a resource-based federated learning method according to some embodiments of the present invention.

[0044] FIG. 4 is a diagram for explaining the learning process of a local model according to one embodiment of the present invention.

[0045] Figure 5 is a block diagram for explaining the learning process of the local model of Figure 4.

[0046] Figure 6 is a block diagram schematically illustrating the local model of Figure 5.

[0047] Figure 7 is a block diagram schematically illustrating the personalized model of Figure 5.

[0048] Figure 8 is a block diagram illustrating a process for generating a feature vector applied to the second personalized model of Figure 5.

[0049] FIG. 9 is a block diagram for explaining the process of receiving global parameters in step S400 of FIG. 3.

[0050] FIG. 10 is a flowchart illustrating an anomaly detection operation using a federated learned local model according to one embodiment of the present invention.

[0051] Fig. 11 is a block diagram for explaining the anomaly detection operation of Fig. 10.

[0052] FIG. 12 is a diagram for explaining the learning process of a local model according to another embodiment of the present invention.

[0053] Figure 13 is a block diagram for explaining the learning process of the local model of Figure 12.

[0054] FIG. 14 is a flowchart illustrating an anomaly detection operation using a federated learned local model according to another embodiment of the present invention.

[0055] Figure 15 is a block diagram for explaining the anomaly detection operation of Figure 14.

[0056] FIG. 16 is a conceptual diagram illustrating a federated learning system according to some other embodiments of the present invention.

[0057] FIG. 17 is a block diagram illustrating components for a global server according to some other embodiments of the present invention.

[0058] FIG. 18 is a flowchart illustrating a resource-based federated learning method according to some other embodiments of the present invention.

[0059] FIG. 19 is a block diagram illustrating a process for deriving global parameters in some other embodiments of the present invention.

[0060] FIG. 20 is a flowchart illustrating an anomaly detection operation and a service provision operation based on the anomaly detection operation using a federated learned local model according to some other embodiments of the present invention.

[0061] FIG. 21 is a diagram illustrating a hardware implementation of a local device or global server performing a resource-based federated learning method according to some embodiments of the present invention.

[0062]

[0063] The terms and words used in this specification and claims should not be interpreted based on their general or dictionary meanings. In accordance with the principle that inventors can define the concepts of terms and words to best describe their inventions, they should be interpreted in a way that is consistent with the technical concept of the present invention. Furthermore, the embodiments described in this specification and the configurations depicted in the drawings are merely examples of how the present invention can be realized and do not fully represent the technical concept of the present invention. Therefore, it should be understood that various equivalents, modifications, and applicable examples may exist as of the time of filing.

[0064] The terms first, second, A, B, etc. used in this specification and claims may be used to describe various components, but the components should not be limited by these terms. These terms are used only 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 referred to as the second component, and similarly, the second component may also be referred to as the first component. The term "and / or" includes any combination of a plurality of related listed items or any item among a plurality of related listed items.

[0065] The terminology used in this specification and claims is for the purpose of describing specific embodiments only and is not intended to limit the present invention. Singular expressions include plural expressions unless the context clearly dictates otherwise. It should be understood that terms such as "comprise" or "have" in this application do not preclude the presence or addition of features, numbers, steps, operations, components, parts, or combinations thereof described in the specification.

[0066] Unless otherwise defined, all terms used herein, including technical or scientific terms, have the same meaning as commonly understood by one of ordinary skill in the art to which the present invention belongs.

[0067] Terms defined in commonly used dictionaries should be interpreted to have a meaning consistent with their meaning in the context of the relevant technology, and will not be interpreted in an idealized or overly formal sense unless expressly defined in this application.

[0068] In addition, each configuration, process, procedure or method included in each embodiment of the present invention may be shared within a scope that is not technically inconsistent with each other.

[0069] Machine learning is a branch of AI that develops algorithms and technologies that enable computers to learn from data. It is a core technology in various fields such as data processing, image recognition, voice recognition, and internet search, and shows excellent performance in prediction and anomaly detection.

[0070] Among these, anomaly detection refers to finding entities or data that contain unexpected patterns in data. Machine learning-based anomaly detection models calculate the difference between actual and predicted data and determine that data is anomalous if the calculated difference exceeds a threshold. This anomaly detection can be used in processes such as "user authentication," which determines whether data entered by a user through a local device is authenticated by the user, or "fraud detection," which determines whether the data resembles typical fraud patterns.

[0071] Meanwhile, in this specification, "federated learning" refers to a learning method performed through data exchange between multiple local devices and a global server, while "local learning" refers to a learning method for a specific model (e.g., a local model or personalized model) performed within each local device. Federated learning and local learning are described in detail below.

[0072] Hereinafter, with reference to FIGS. 1 to 21, a resource-based federated learning method according to some embodiments of the present invention and a federated learning system including a local device and server performing the same will be described.

[0073]

[0074] FIG. 1 is a conceptual diagram illustrating a federated learning system according to some embodiments of the present invention.

[0075] Referring to FIG. 1, a federated learning system according to some embodiments of the present invention includes a local device (100) and a global server (200). Here, the global server (200) operates in connection with the local device (100) via a communication network (300) and can transmit and receive data with the local device (100). At this time, the global server (200) can operate in connection with a plurality of local devices (100a to 100k) and can transmit and receive data between them.

[0076] The global server (200) can operate as a host for federated learning that operates in conjunction with each local device (100a to 100k). At this time, the global server (200) can receive local parameters derived through local learning from each local device (100a to 100k) and derive global parameters based on the received multiple local parameters.

[0077] Meanwhile, each local device (100a to 100k) can operate as a device that performs local learning within the device (i.e., in an on-device form) using a local model and performs user authentication or anomaly detection using a local model that reflects global parameters derived from a global server (200).

[0078] In FIG. 1, the local device (100) is depicted as a server, but the present invention is not limited thereto and can be applied without limitation to devices capable of performing local learning as described above.

[0079] For example, the local device (100) may include various types of electronic devices such as a personal computer (PC), a laptop, a tablet, a mobile phone, a smart phone, a wearable device (e.g., a head-mounted display (HMD) or a watch-type terminal).

[0080] As another example, the local device (100) may be a device operated by a financial institution that provides financial services to user terminals (not shown) in a wired / wireless communication environment. Although not explicitly depicted in the drawing, each local device (100a to 100k) may be implemented and operated in the form of a server-client system with a user terminal (not shown) that utilizes the services provided by the financial institution.

[0081] At this time, each local device (100a to 100k) can store and manage the user's subscription name information, user authentication information, and activity information in the customer account corresponding to each user, and can provide various financial services through a financial application installed on the user terminal (not shown).

[0082] Additionally, each local device (100a to 100k) may request user data necessary to provide the financial service requested by the user prior to providing the financial service. The user data may be data required for user authentication or anomaly detection of a customer using a user terminal (not shown). For example, user data required for user authentication may include an image captured by the user (e.g., a facial image), user input data (e.g., touch pattern information), or the user's financial activity data. However, this is merely an example, and the present invention is not limited thereto.

[0083] In some embodiments of the present invention, each local device (100a to 100k) may be configured to independently collect information and determine whether to authenticate a user or detect an anomaly, rather than a centralized analysis method in which the collected customer information is transmitted to a central server (i.e., a global server (200)) for analysis and then the analyzed results are transmitted again. This method not only enables fast processing through low latency because the information is processed within each local device (100a to 100k), but also resolves security issues such as personal information of multiple users being leaked or hacked at once.

[0084] In addition, the present invention performs federated learning in which only the weights for multiple local models included in each local device (100a to 100k) are shared with the global server (200), thereby minimizing performance degradation due to data heterogeneity that occurs when using local data collected from multiple devices, and preventing performance degradation due to differences in the size and distribution of local data.

[0085] In addition, the communication network (300) plays a role of connecting the global server (200) and a plurality of local devices (100a to 100k). That is, the communication network (300) refers to a communication network that provides a connection path so that the local devices (100a to 100k) can transmit and receive data after connecting to the global server (200). The communication network (300) may include wired networks such as LANs (Local Area Networks), WANs (Wide Area Networks), MANs (Metropolitan Area Networks), and ISDNs (Integrated Service Digital Networks), or wireless networks such as wireless LANs, CDMA, Bluetooth, and satellite communication, but the scope of the present invention is not limited thereto.

[0086]

[0087] Meanwhile, in some embodiments of the present invention, a local device (100) may act as an executor of a resource-based federated learning method according to some embodiments of the present invention. However, the present invention is not limited thereto, and each step included in the resource-based federated learning method of the present invention may be performed in either the global server (200) or the local device (100), or may be performed together in the global server (200) and the local device (100).

[0088] Meanwhile, in some other embodiments of the present invention, a global server (200) may act as the execution entity of a resource-based federated learning method according to some embodiments of the present invention. This will be described in detail later with reference to FIGS. 16 to 20.

[0089] For convenience of explanation, in the following, a resource-based federated learning method according to some embodiments of the present invention will be described as an example in which a specific local device (100a; hereinafter, a local device) is used as the performer.

[0090]

[0091] FIG. 2 is a block diagram illustrating components for a local device according to some embodiments of the present invention.

[0092] Referring to FIG. 2, the local device (100a) includes an interface (110), a database (120), a processor (130), and a memory (140). At this time, a federated learning module (FLM), a parameter adjustment module (PAM), a loss-extract module (LEM), and an abnormal detection module (ADM) may be loaded into the memory (140) and driven (or executed) by the processor (130). Each module may be stored in the form of a computer program in the database (120) or storage (not shown) included in the local device (100a) and utilized. In addition, in some embodiments of the present invention, some of the above-described modules may be omitted and implemented.

[0093] Specifically, the interface (110) can generate user data based on user input entered by the user on the local device (100a) and transmit the generated user data to other components within the local device (100a). The interface (110) can be connected to an input / output device provided on the local device (100a) and configured to receive user input. At this time, the input / output device can be at least one of a camera, a pad, a keyboard, a mouse, a touchpad, a touchscreen, and a display device, but the present invention is not limited thereto.

[0094] Additionally, the interface (110) performs a function of exchanging data with the global server (200). The interface (110) may include various communication modules and may perform data exchange between the global server (200) or a user terminal (not shown) via a communication network (300).

[0095] The database (120) can store user-related data (i.e., user data) received from the interface (110). At this time, the user data can include data entered by the user in a financial application, data for user authentication (e.g., facial image, biometric data, etc.), unknowing data collected while the user uses the application (Unaware data), the user's financial transaction data, etc.

[0096] For example, the database (120) may store not only data entered by the user in the financial application (e.g., user ID, depositor name, application financial service details, financial transaction password, etc.), but also data for user authentication (e.g., facial image captured by the camera of the local device (100a), ID image, biometric information, security code, etc.). As another example, the database (120) may store sensing data for touch patterns generated within the application installed in the local device (100a), key strokes entered by the user, log data or cookies for the user's application usage history, etc. As another example, the database (120) may store data for the user's past financial transaction history recorded in the user's account. However, these are only a few examples, and the present invention is not limited thereto.

[0097] In the following, user data generated from a local device (100a) and stored in a database (120) is defined as local data and explained, and the local data can be used to train a local model (LM) or personalized model (PM) to be explained later.

[0098] Meanwhile, the processor (130) may execute software to control at least one other component (e.g., hardware or software component) of the local device (100a) and perform various data processing and operations. For example, the processor (130) may load information, commands, or data received from another component (e.g., interface (110)) into the memory (140), perform operations using the loaded information, commands, or data, and store the resulting data in the memory (140) or database (120).

[0099] The memory (140) can store and load various data used in at least one component (e.g., processor (130)) of the local device (100a). For example, the data can include input data or output data for software and commands related thereto.

[0100] Accordingly, the processor (130) can load and use modules or instructions related to various operations of the resource-based federated learning method according to some embodiments of the present invention on the memory (140).

[0101]

[0102] First, the processor (130) can perform user authentication or anomaly detection on user data using a federated learning module (FLM) loaded into the memory (140). To this end, the processor (130) trains the federated learning module (FLM) using local data stored in the database (120).

[0103] At this time, the federated learning module (FLM) includes a local model (LM) and a personalized model (PM).

[0104] Specifically, the local model (LM) can input local data (i.e., user data) and generate a vector value (hereinafter, a first vector value) as an output thereof. In addition, the local model (LM) can input augmented data for the user data and generate a vector value (hereinafter, a second vector value) as an output thereof. Here, the local model (LM) may include various types of pre-trained deep learning models, and the local model (LM) may include a neural network composed of multiple layers, each layer being connected to multiple neural networks. In addition, the augmented data may mean data that rotates the user data or transforms a portion of the user data.

[0105] Meanwhile, the personalized model (PM) may include a first personalized model (PM1) and / or a second personalized model (PM2). Like the local model (LM), the personalized model (PM) may be composed of multiple layers, each layer including a neural network connected to multiple neural networks.

[0106] The first personalized model (PM1) can receive the first vector value output from the local model (LM) as input and generate a corresponding vector value (hereinafter, the first output value). At this time, the first output value output from the first personalized model (PM1) can be used to calculate the first loss value in the loss calculation module (LEM).

[0107] In addition, the second personalized model (PM2) can receive the second vector value output from the local model (LM) and the synthetic vector calculated based on the feature vector, and generate a vector value (hereinafter, the second output value) corresponding thereto. At this time, the second output value output from the second personalized model (PM2) is used to calculate the second loss value in the loss calculation module (LEM). Here, the method of generating the feature vector and generating the synthetic vector based thereon will be described in detail with reference to FIGS. 5 and 8 below.

[0108] In one embodiment of the present invention, the first personalized model (PM1) can be used both when training a local model (LM) on a local device (100a) and when performing user authentication or anomaly detection using the local model (LM). Conversely, the second personalized model (PM2) can only be used when training a local model (LM).

[0109] Meanwhile, in another embodiment of the present invention, the first personalized model (PM1) may be omitted, and only the second personalized model (PM2) may be implemented. In this case, as in the first embodiment, the second personalized model (PM2) may only be used during the training of the local model (LM). A detailed description of another embodiment of the present invention will be provided below with reference to FIGS. 12 to 15.

[0110]

[0111] In addition, the processor (130) can adjust the size of at least one of a plurality of layers (i.e., layers constituting the first personalized model (PM1) or the second personalized model (PM2)) included in the personalized model (PM) using the parameter adjustment module (PAM) loaded in the memory (140). Specifically, the parameter adjustment module (PAM) can determine the size of the personalized model parameter to be applied to the personalized model (PM) of the local device (100a) based on hardware information of the local device (100a) or the size of a pre-stored dataset.

[0112] In other words, the personalized model (PM) includes an input layer, an output layer, and at least one hidden layer, wherein the size of the at least one hidden layer can be varied according to the size of the personalized model parameter determined by the parameter adjustment module (PAM) based on hardware information of the local device (100a) or the size of a pre-stored dataset.

[0113] That is, the size of the hidden layer included in the personalized model (PM) can be adjusted based on hardware information of the local device (100a) or the size of a pre-stored dataset. Specifically, the size of the hidden layer can be determined using a pre-defined function or relatively determined based on information about other local devices (100a).

[0114] In some embodiments of the present invention, the local device (100a) may be the entity determining the size of the hidden layer. However, the present invention is not limited to this, and in other embodiments of the present invention, the global server (200) may determine the size of the hidden layer included in the personalized model (PM). This will be described later with reference to FIGS. 16 to 20.

[0115] Additionally, in some other embodiments of the present invention, the size of the hidden layer included in the local model (LM) as well as the personalized model (PM) can be adjusted in the same manner as the personalized model (PM). However, for convenience of explanation, the following example will illustrate a case where only the size of the hidden layer included in the personalized model (PM) is varied.

[0116]

[0117] Next, the processor (130) can calculate a loss value by comparing a vector value output from a local model (LM) or a personalized model (PM) with a reference vector for local data through a loss calculation module (LEM) loaded into a memory (140). Here, the reference vector may be a vector representing the ground truth for local data (i.e., user data) and may be stored in advance in a database (120) and used.

[0118] Next, the processor (130) can train a local model (LM) or a personalized model (PM) based on the calculated loss value. Specifically, the processor (130) can train the local model (LM) or the personalized model (PM) by adjusting the weights of each node included in the neural network of the local model (LM) or the personalized model (PM) so that the loss value between the vector value calculated from the local model (LM) or the personalized model (PM) and the reference vector is reduced. At this time, the processor (130) can train the local model (LM) or the personalized model (PM) so that the loss value is reduced using the cosine similarity function. In addition, the processor (130) can train the local model (LM) or the personalized model (PM) so that the loss value is reduced using the gradient descent function. However, this is merely an example and the present invention is not limited thereto.

[0119] Next, the processor (130) transmits the weights (i.e., local parameters) of the neural network included in the local model (LM) learned in the local device (100a) to the global server (200) through the interface (110).

[0120] At this time, the global server (200) calculates a global parameter using local parameters received from multiple local devices (e.g., 100a to 100k) and transmits the calculated global parameter back to each local device (e.g., 100a to 100k).

[0121] Next, the processor (130) updates the neural network of the local model (LM) based on the global parameters received from the global server (200) through the interface (110).

[0122]

[0123] Meanwhile, the local device (100a) can determine whether there is an abnormality in newly input user data using a local model (LM) (or a local model (LM) and a personalized model (PM)) learned in advance through the aforementioned process, and can perform user authentication or anomaly detection based on this.

[0124] Specifically, the processor (130) can use the anomaly detection module (ADM) loaded in the memory (140) to determine whether there is an anomaly in newly input user input data or whether there is an anomaly in the user's financial transaction currently in progress. That is, the anomaly detection module (ADM) is used in the inference stage of the federated learning method according to some embodiments of the present invention, and determines whether there is an anomaly in user data based on output data derived using a pre-learned local model (LM) (or, local model (LM) and personalized model (PM)), and based on this, determines whether user authentication or anomaly transaction has occurred.

[0125] For example, if the output data's abnormal score is lower than a predetermined threshold, the user may be determined to be the user, and thus user authentication may be approved or the transaction may not be considered abnormal. If the abnormal score is higher than the threshold, the user may be determined to be someone else, and thus user authentication may be rejected or the transaction may be considered abnormal. However, this is merely an example, and the present invention is not limited thereto.

[0126] Meanwhile, in some embodiments of the present invention, the loss calculation module (LEM) and the anomaly detection module (ADM) may be partially implemented in the local device (100a) or partially implemented in the global server (200).

[0127] Below, we will examine in detail the operation of a resource-based federated learning method according to some embodiments of the present invention.

[0128]

[0129] Figure 3 is a flowchart illustrating a resource-based federated learning method according to some embodiments of the present invention. For convenience of explanation, the following description will be given as an example where the resource-based federated learning method according to some embodiments of the present invention is performed by a local device (100a) or a processor (130).

[0130] Referring to FIG. 3, the local device (100a) determines hardware information of the local device (100a) or the size of a pre-stored dataset (S100). Here, the hardware information refers to a performance indicator of the local device (100a), and the pre-stored dataset may refer to the amount of data that the local device (100a) has pre-stored.

[0131] For example, the performance indicator of a local device (100a) may be determined by the amount of computation that the local device (100a) can process per unit time. However, the present invention is not limited thereto, and it goes without saying that various indicators that can represent the hardware resources of the local device (100a) may be used as the performance indicator of the local device (100a).

[0132] Additionally, the size of the dataset pre-stored in the local device (100a) may be determined by the number of users or financial data related to table data pre-stored in a database linked to the local device (100a). However, this is merely an example, and the present invention is not limited thereto.

[0133] Next, the local device (100a) determines the size of the personalized model parameters to be applied to the personalized model (PM) of the local device (100a) based on the identified hardware information or the size of the pre-stored dataset (S200). At this time, the personalized model parameters may be derived using a pre-defined function based on the size of the pre-stored dataset of the local device (100a), or may be derived using a pre-defined function based on the performance indicators of the local device (100a) derived based on the hardware information of the local device (100a).

[0134] For example, the size of the personalized model parameters can be determined using a step function such as <Mathematical Formula 1> below.

[0135]

[0136] <Mathematical Formula 1>

[0137]

[0138] Here, D k represents the size or performance indicator of the dataset, τ represents the maximum size or performance indicator of the dataset, β represents the slope constant of the step function (initial value: 0.75), and d represents the size of the default value of the personalized model parameter. However, this is only one example, and the present invention is not limited thereto.

[0139]

[0140] Next, the local device (100a) applies the determined personalized model parameters to the personalized model (PM) and trains the local model (LM) of the local device (100a) using the personalized model (PM) (S300). A detailed description of the training process of the local model (LM) will be provided below with reference to FIGS. 4 to 8.

[0141] Next, the local device (100a) transmits local parameters for the weights of the neural network included in the local model (LM) to the global server (200) and receives global parameters derived based on the local parameters from the global server (200) (S400). This will be described later with reference to FIG. 9.

[0142] Next, the local device (100a) applies the received global parameters to a local model (LM) and derives an output value for the new user data using the local model (LM). Subsequently, the local device (100a) can perform user authentication or anomaly detection operations on the new user data based on the derived output value (S500). A detailed description of the inference process using the local model (LM) will be described below with reference to FIGS. 10 and 11.

[0143] Below, a description will be given of the learning process of a local model (LM) according to one embodiment of the present invention.

[0144]

[0145] FIG. 4 is a diagram illustrating a learning process of a local model according to one embodiment of the present invention. FIG. 5 is a block diagram illustrating a learning process of the local model of FIG. 4. FIG. 6 is a block diagram schematically illustrating the local model of FIG. 5. FIG. 7 is a block diagram schematically illustrating the personalized model of FIG. 5. FIG. 8 is a block diagram illustrating a process of generating a feature vector applied to the second personalized model of FIG. 5.

[0146] Likewise, for the convenience of explanation, the following description will be given as an example in which the execution entity of the resource-based federated learning method according to one embodiment of the present invention is a local device (100a) or a processor (130). In addition, in the training process (training stage) of the federated learning model (FLM) according to one embodiment of the present invention, the personalized model (PM) is implemented by including a first personalized model (PM1) and a second personalized model (PM2).

[0147] First, referring to FIGS. 4 and 5, the processor (130) receives user data ( ) is applied to the local model (LM), and the first vector value ( ) is acquired (S310). At this time, the local device (100a) can store input data entered by the user through the interface (110) or financial transaction data generated based thereon in the database (120).

[0148] Here, the user data used in the local device (100a) ) may contain various types of data as described above. For example, user data ( ) may include data entered by the user in the financial application, data for user authentication (e.g., facial image, biometric data, etc.), unintentional data (Unaware data) collected while the user uses the application, and the user's financial transaction data. However, for the convenience of explanation, the following description will be given as an example of using an image captured by a camera equipped in a local device (100a).

[0149] Meanwhile, referring to FIG. 6, the local model (LM) may include a deep learning neural network composed of multi-layered layers. At this time, input data and output data used for machine learning may be stored in the database (120) or memory (140) of the local device (100a).

[0150] To explain in more detail, deep learning, a type of machine learning technology, learns at a deep level in multiple stages based on data.

[0151] Deep learning refers to a set of machine learning algorithms that extract core data from multiple data sets by increasing the level.

[0152] Local models (LMs) can utilize a variety of well-known deep learning architectures. For example, local models (LMs) can utilize models with structures such as convolutional neural networks (CNNs), recurrent neural networks (RNNs), deep belief networks (DBNs), and graph neural networks (GNNs), as well as models such as transformers or XGboost.

[0153] The training of an artificial neural network (ANN) using a local model (LM) can be achieved by adjusting the weights of connections between nodes (and, if necessary, adjusting the bias value) to produce the desired output for a given input. An ANN can continuously update its weight values ​​through learning. Methods such as backpropagation can be used for training the ANN.

[0154] Meanwhile, an artificial neural network pre-trained through machine learning may be installed in the memory (140) of the local device (100a).

[0155] The processor (130) can utilize a local model (LM) loaded on the memory (140), and the local model (LM) can perform machine learning using local data as input. Both supervised learning and semi-supervised learning can be used as machine learning methods of the artificial neural network. In addition, the local model (LM) can be controlled by the processor (130) so that the artificial neural network structure for outputting an output vector close to a reference vector after learning is automatically updated according to the settings.

[0156] At this time, the local model (LM) includes an input layer that uses user data as an input node, an output layer that uses the vector value of the data (i.e., output data) as an output node, and M hidden layers placed between the input layer and the output layer.

[0157] Here, weights can be assigned to the edges connecting the nodes of each layer. These weights or the presence or absence of edges can be added, removed, or updated during the learning process. Therefore, the weights of the nodes and edges between the k input nodes and i output nodes can be updated during the learning process.

[0158] Before a local model (LM) performs training, all nodes and edges can be set to initial values. However, as information accumulates, the weights of nodes and edges change, and this process can create a match between the parameters input as learning factors (i.e., input data) and the values ​​assigned to output nodes (i.e., output data).

[0159] The weights of the nodes and edges between the input nodes and the output nodes that constitute the local model (LM) can be updated by the learning process of the local model (LM) performed within the local device (100a) by the processor (130).

[0160] For example, the processor (130) calculates a loss value by comparing an output vector produced by a local model (LM) with a reference vector for input data. Here, the reference vector may be a vector value indicating the correct answer for the input data, and may be stored in advance in the database (120) and used. Subsequently, the processor (130) may train the local model (LM) based on the calculated loss value. Specifically, the processor (130) may train the local model (LM) by adjusting the weights of each node included in the local model (LM) so that the loss value between the output vector produced by the local model (LM) and the reference vector becomes smaller. However, this is only one example of a method for training a local model (LM), and the present invention is not limited thereto.

[0161] Additionally, the weights of nodes and edges between input and output nodes that constitute the local model (LM) can be updated based on global parameters received from the global server (200). A detailed description of this will be provided later with reference to FIG. 9.

[0162] Next, referring again to FIGS. 4 and 5, the processor (130) obtains the first vector value ( ) is applied to the first personalized model (PM1), and the first output value ( which is the output of the first personalized model (PM1) ) is received from the loss calculation module (LEM) (S320).

[0163] Here, the first personalized model (PM1) may have a structure substantially similar to the local model (LM) described above with reference to FIG. 6.

[0164] For example, referring to Fig. 7, the first personalized model (PM1) is composed of multiple layers. At this time, the multiple layers are input layers ( ), output layer ( ) and the input layer ( ) and the output layer ( ) placed between at least one hidden layer ( ) and at least one hidden layer ( ) can be applied with personalized model parameters of the size determined in the aforementioned S200 step.

[0165] In other words, the hidden layer ( ) can be adjusted according to the hardware information of the local device (100a) or the size of the pre-stored dataset, and the processor (130) adjusts the hidden layer ( ) can be used to train a local model (LM).

[0166] Meanwhile, referring again to FIGS. 4 and 5, the processor (130) processes user data ( Augmented data for ( ) is generated and applied to the local model (LM), and the second vector value ( ) is obtained (S330). Here, augmented data ( ) is user data ( ) (e.g., a user's face image) or rotate user data ( ) may contain data that has been altered from some portion of the user's financial transaction data.

[0167] Next, the processor (130) acquires the second vector value ( ) and feature vector ( ) based on the synthetic vector ( ) is applied to the second personalized model (PM2), and the second output value ( which is the output of the second personalized model (PM2) ) is received from the loss calculation module (LEM) (S340).

[0168] Here, the feature vector ( ) means the vector value output from the pre-trained model by inputting public data into the pre-trained model.

[0169] For example, referring to Fig. 8, the feature vector ( ) may include output data for public data (e.g., multiple facial images crawled and published on a web page) input to a pre-trained model (PTM). At this time, the feature vector ( ) can be used as an auxiliary means to supplement insufficient input data.

[0170] That is, the feature vector ( ) is the augmented data mentioned above ( ) obtained based on the second vector value ( ) and merged into a composite vector ( ) can be used to create a composite vector ( ) is the second vector value ( ) and feature vector ( ) can be generated through the concatenation of. However, this is only one example, and the present invention is not limited thereto.

[0171] Next, the generated composite vector ( ) is input to the second personalized model (PM2) and the second output value ( ) is output. At this time, the second personalized model (PM2) is composed of multiple layers, similar to the first personalized model (PM1) described above, and includes at least one hidden layer ( ) can be applied with the personalized model parameters of the size determined in the aforementioned step S200. Then, the processor (130) outputs the second output value (which is the output of the second personalized model (PM2). ) and receives the second loss value (L2) calculated based on the result.

[0172] Next, referring again to FIGS. 4 and 5, the processor (130) trains the local model (LM) using the first loss value (L1) and the second loss value (L2) calculated by the loss calculation module (LEM) (S350). At this time, the processor (130) can train the local model (LM) so that the first loss value (L1) and the second loss value (L2) become smaller, and the process of training the local model (LM) may correspond to local learning (i.e., on-device learning) performed within the local device (100a).

[0173] Next, the processor (130) embeds local parameters (LM) in the neural network of the local model (LM) learned through the aforementioned process. ) is transmitted to the global server (200).

[0174] Below, we will look at the process of receiving global parameters derived from multiple local parameters from a global server (200).

[0175]

[0176] FIG. 9 is a block diagram for explaining the process of receiving global parameters in step S400 of FIG. 3.

[0177] Referring to FIG. 9, the first local device (100a) trains the first local model (LMa) using local data stored therein, and trains the first local parameter (i.e., neural network) of the neural network constituting the first local model (LMa). ) is transmitted to the global server (200). Similarly, the second local device (100b) also trains the second local model (LMb) using the local data stored therein, and the second local parameters ( of the neural network constituting the second local model (LMb) ) is transmitted to the global server (200).

[0178] Next, the global server (200) receives local parameters ( , ) using global parameters ( ) is derived. At this time, the global server (200) receives a plurality of local parameters ( , ) to derive the average value of each local parameter ( , ) using various methods such as applying different ratios to each global parameter ( ) can be derived.

[0179] Next, the global server (200) derives the global parameters ( ) is transmitted to each local device (100a, 100b). Accordingly, each local device (100a, 100b) transmits the local parameters ( , ) in response to global parameters ( ) can be received.

[0180] Next, each local device (100a, 100b) receives the global parameters ( ) can be used to update each local model (LMa, LMb). For example, the first local device (100a) may receive the received global parameters ( ) can be used to update the neural network that constitutes the first local model (LMa). Similarly, the second local device (100b) can also update the received global parameters ( ) can be used to update the neural network that constitutes the second local model (LMb). The local devices (100a, 100b) described above receive global parameters ( ) to update the neural network that constitutes the first learning model (LMa, LMb) using the global parameters ( ) can mean applying the neural network of the local model (LMa, LMb).

[0181] That is, the global server (200) receives local parameters ( , ) based on global parameters ( ) and perform federated learning to apply it to the local models (LMa, LMb) of each local device (100a, 100b), thereby improving the learning performance of the local models (LMa, LMb) without sharing data related to personal information generated in the local devices (100a, 100b) with other local devices (100a, 100b) or the global server (200). Through this, the present invention can enhance the accuracy of user authentication or anomaly detection while strengthening personal information protection for users.

[0182] Below, we will specifically examine an anomaly detection operation using a federated learned local model (LM) with global parameters applied according to one embodiment of the present invention.

[0183]

[0184] FIG. 10 is a flowchart illustrating an anomaly detection operation using a federated learned local model according to one embodiment of the present invention. FIG. 11 is a block diagram illustrating the anomaly detection operation of FIG. 10.

[0185] Likewise, for the convenience of explanation, the following description will be given as an example in which the execution entity of the resource-based federated learning method according to one embodiment of the present invention is a local device (100a) or a processor (130). In addition, in the inference process (inference stage) of the federated learning model (FLM) according to one embodiment of the present invention, the personalized model (PM) is executed using only the first personalized model (PM1), omitting the second personalized model (PM2).

[0186] Referring to FIGS. 10 and 11, the processor (130) uses the global parameters described above ( ) applied to the local model (LM) with new user data ( ) is applied, and the first vector value ( ) is received (S510). Here, new user data ( ) may include data entered by the user in the financial application, data for user authentication (e.g., facial image, biometric data, etc.), unknowing data collected while the user uses the application (Unaware data), and the user's financial transaction data.

[0187] Next, the processor (130) generates a first vector value ( ) is applied to the first personalized model (PM1), and the first output value ( ) is received (S520).

[0188] Next, the processor (130) outputs the first output value ( ) is applied to the anomaly detection module (ADM), and new user data ( ) performs user authentication or anomaly detection (S530).

[0189] At this time, the anomaly detection module (ADM) receives the first output value ( ) and a similarity with a predetermined standard can be calculated to output a result value (ADR), and if the result value (ADR) output from the anomaly detection module (ADM) is within a predetermined range, the processor (130) outputs user data ( ) can be judged to be free of abnormalities.

[0190] In summary, the resource-based federated learning method according to one embodiment of the present invention determines the size of personalized model parameters to be applied to the personalized model of a local device based on the hardware information of each local device or the size of a pre-stored dataset, and performs federated learning of the local model using the personalized model to which the adjusted personalized model parameters are applied, thereby increasing the efficiency of federated learning and the accuracy of anomaly detection.

[0191] Furthermore, the present invention can maintain the load applied to the local device during the learning process at an appropriate level by adjusting the size of the personalized model parameters applied to the personalized model based on resource information from the local device. This allows the present invention to minimize the load applied to the local device during the local model learning process while simultaneously increasing the accuracy of anomaly detection.

[0192] Below, we will look at a federated learning method according to another embodiment of the present invention that is different from the federated learning method according to one embodiment of the present invention described above.

[0193]

[0194] FIG. 12 is a diagram illustrating a learning process of a local model according to another embodiment of the present invention. FIG. 13 is a block diagram illustrating a learning process of the local model of FIG. 12. FIG. 14 is a flowchart illustrating an anomaly detection operation using a federated learned local model according to another embodiment of the present invention. FIG. 15 is a block diagram illustrating the anomaly detection operation of FIG. 14. In the following, overlapping content with the aforementioned embodiment of the present invention will be omitted, and the differences will be primarily described.

[0195] In the training stage of a federated learning model (FLM) according to another embodiment of the present invention, the personalized model (PM) omits the first personalized model (PM1) and uses only the second personalized model (PM2) described above. Furthermore, in the inference stage of a federated learning model (FLM) according to another embodiment of the present invention, the federated learning model (FLM) omits the personalized model (PM) and is implemented using only the local model (LM).

[0196] Specifically, referring to FIGS. 12 and 13, the processor (130) receives user data ( ) is applied to the local model (LM), and the first vector value ( ) is obtained (S310).

[0197] Next, the processor (130) obtains the first vector value ( ) is received from the loss calculation module (LEM) (S325).

[0198] Meanwhile, the processor (130) processes user data ( Augmented data for ( ) is generated and applied to the local model (LM), and the second vector value ( ) is obtained (S330). Here, augmented data ( ) is user data ( ) (e.g., a user's face image) or rotate user data ( ) may contain data that has been altered from some portion of the user's financial transaction data.

[0199] Next, the processor (130) acquires the second vector value ( ) and feature vector ( ) based on the synthetic vector ( ) is applied to the personalized model (PM), and the second output value ( which is the output of the personalized model (PM) ) is received from the loss calculation module (LEM) (S340).

[0200] Here, the personalized model (PM) may have a structure substantially similar to the first personalized model (PM1) described above with reference to FIG. 7. Accordingly, at least one hidden layer ( ) can be applied with personalized model parameters of the size determined in the aforementioned S200 step.

[0201] Next, the processor (130) trains the local model (LM) using the first loss value (L1) and the second loss value (L2) calculated by the loss calculation module (LEM) (S350). At this time, the processor (130) can train the local model (LM) so that the first loss value (L1) and the second loss value (L2) become smaller.

[0202] Next, the processor (130) embeds local parameters (LM) in the neural network of the local model (LM) learned through the aforementioned process. ) is transmitted to the global server (200).

[0203] Next, the processor (130) receives global parameters ( ) and receives the received global parameters ( ) is applied to the local model (LM).

[0204] Next, referring to FIGS. 14 and 15, the processor (130) determines the global parameters ( ) applied to the local model (LM) with new user data ( ) is applied, and the first vector value ( ) is received (S510).

[0205] Next, the processor (130) generates a first vector value ( ) is applied to the anomaly detection module (ADM), and new user data ( ) performs user authentication or anomaly detection (S535).

[0206] At this time, the anomaly detection module (ADM) receives the first vector value ( ) and a similarity with a predetermined standard can be calculated to output a result value (ADR), and if the result value (ADR) output from the anomaly detection module (ADM) is within a predetermined range, the processor (130) outputs user data ( ) can be judged to be free of abnormalities.

[0207] That is, the resource-based federated learning method according to another embodiment of the present invention can omit the first personalized model (PM1) from the personalized model (PM) and utilize only the second personalized model (PM2). Accordingly, the resource-based federated learning method according to another embodiment of the present invention can use the personalized model (PM) only during the learning process and not during the inference process.

[0208]

[0209] Additionally, although not explicitly illustrated in the drawing, a resource-based federated learning method according to another embodiment of the present invention can omit the second personalized model (PM2) from the personalized model (PM) and utilize only the first personalized model (PM1). In this case, the resource-based federated learning method according to another embodiment of the present invention can utilize only the first personalized model (PM1) in both the learning and inference processes.

[0210] However, these are only a few examples of the present invention, and it is obvious that various models including at least one hidden layer whose size varies depending on hardware information of the local device (100a) or a pre-stored dataset may be additionally utilized.

[0211] Below, we will examine a federated learning system according to several other embodiments of the present invention. Furthermore, we will examine in detail the configuration and operation of a global server (200) that performs a resource-based federated learning method according to several other embodiments of the present invention.

[0212]

[0213] Figure 16 is a conceptual diagram illustrating a federated learning system according to several other embodiments of the present invention. Below, any overlap with the previously described content will be omitted, and the differences will be primarily discussed.

[0214] Referring to FIG. 16, a federated learning system according to several other embodiments of the present invention includes a local device (100) and a global server (200) (hereinafter, "server"). Here, the server (200) operates in connection with the local device (100) via a communication network (300) and can transmit and receive data with the local device (100). Similarly, the server (200) can operate in connection with a plurality of local devices (100a to 100k) and can transmit and receive data between them.

[0215] In some other embodiments of the present invention, the server (200) and the local device (100) may be implemented as a server-client system. For example, the server (200) may be a server operated by a financial institution, and the local device (100) may be a user terminal utilizing a service provided by the financial institution.

[0216] Accordingly, the server (200) can store and manage the user's subscription name information, user authentication information, and activity information in the customer account corresponding to each user, and can provide various financial services through the financial application installed on the local device (100).

[0217] At this time, the financial application may be a dedicated application for providing financial services or a web browsing application. Here, the dedicated application may be an application built into the local device (100) or an application downloaded from an application distribution server (not shown) and installed on the local device (100).

[0218] Before providing the financial service requested by the user, the server (200) may request user data necessary to provide the financial service. This user data may be data required for user authentication of a customer using the local device (100). For example, user data required for user authentication may include an image captured by the user, user input data (e.g., touch pattern information), or the user's financial activity data. However, this is merely an example, and the present invention is not limited thereto.

[0219] At this time, the local device (100) can receive user data required for authentication from the user, and can transmit the output value for the user data input into the local device (100) to the server (200) using a pre-learned federated learning module (e.g., FLM of FIG. 20). Then, the server (200) can determine whether the user data is abnormal based on the received output value, and can enable the local device (100) to provide financial services based on this.

[0220] That is, in some other embodiments of the present invention, user authentication or anomaly detection may be performed on the server (200) based on output data output from the federated learning module of the local device (100a). In this case, the server (200) performs user authentication or anomaly detection on the user based on the output data of the federated learning module (FLM) received from the local device (100a). Then, if the result of the user authentication or anomaly detection is determined to be normal, the server (200) may provide the local device (100a) with a financial service related to the specific user along with a result of authentication completion or no anomaly.

[0221] For convenience of explanation, the following description will be given as an example in which the server (200) (i.e., global server) is used as the performer of the resource-based federated learning method according to some embodiments of the present invention.

[0222]

[0223] Figure 17 is a block diagram illustrating components of a global server according to several other embodiments of the present invention. Below, any overlap with the previously described content will be omitted, and the differences will be primarily discussed.

[0224] Referring to FIG. 17, the server (200) includes an interface (210), a database (220), a processor (230), and a memory (240). At this time, a federated learning module (FLM), a parameter decision module (hereinafter, PDM), and an anomaly detection module (ADM) may be loaded into the memory (240) and driven (or executed) by the processor (230). Each module may be stored in the form of a computer program in the database (220) or storage (not shown) included in the server (200) and utilized. In addition, in some embodiments of the present invention, some of the modules described above may be omitted and implemented.

[0225] Specifically, the interface (210) performs a function of exchanging data with the local device (100). The interface (210) may include various communication modules and may perform data exchange between a plurality of local devices (100a to 100k) through a communication network (300).

[0226] The database (220) can store user-related data (i.e., user data) received from the interface (210). At this time, the user data can include data entered by the user in a financial application, data for user authentication (e.g., facial image, biometric data, etc.), unintentional data collected while the user uses the application (Unaware data), the user's financial transaction data, etc.

[0227] The processor (230) may execute software to control at least one other component (e.g., hardware or software component) of the server (200) and perform various data processing and operations. For example, the processor (230) may load information, commands, or data received from another component (e.g., interface (210)) into the memory (240), perform operations using the loaded information, commands, or data, and store the resulting data in the memory (240) or database (220).

[0228] The memory (240) can store and load various data used in at least one component (e.g., processor (230)) of the server (200). For example, the data can include input data or output data for software and commands related thereto.

[0229] Accordingly, the processor (230) can load and use modules or instructions related to various operations of the resource-based federated learning method according to some embodiments of the present invention on the memory (240).

[0230] First, the processor (230) can determine the size of a personalized model parameter to be applied to a personalized model (PM) included in each local device (100a-100k) based on the hardware information of each local device (100a-100k) or the size of a pre-stored dataset using a parameter determination module (PDM) loaded in the memory (240).

[0231] In some other embodiments of the present invention, the server (200) may be the entity that determines the size of the hidden layer included in the personalized model (PM) of each local device (100a-100k). At this time, the personalized model (PM) of each local device (100a-100k) includes an input layer, an output layer, and at least one hidden layer. At this time, the size of the at least one hidden layer may be determined by the parameter determination module (PDM) of the server (200) based on the hardware information of each local device (100a-100k) or the size of a pre-stored dataset. That is, the size of the hidden layer may be adjusted by the server (200) based on the hardware information of each local device (100a-100k) or the size of a pre-stored dataset.

[0232] Here, hardware information may refer to the performance indicators of the local device (100a-100k), and the pre-stored dataset may refer to the amount of data that each local device (100a-100k) has pre-stored.

[0233] For example, the performance indicator of the local device (100) may be determined by the amount of computation that can be processed per unit time by each local device (100a-100k). However, the present invention is not limited thereto, and it goes without saying that various indicators that can represent the hardware resources of the local device (100) may be used as the performance indicator of the local device (100).

[0234] Additionally, the size of the dataset pre-stored in the local device (100) may be determined by the number of financial data related to table data pre-stored in a database linked to the local device (100). However, this is merely an example, and the present invention is not limited thereto.

[0235] Additionally, the processor (230) can perform federated learning using a global model (GM) of a federated learning module (FLM) loaded in the memory (240). To this end, the processor (230) transmits a plurality of local parameters received from a plurality of local devices (100a to 100k) to the global model (GM) via the interface (210) and acquires global parameters output from the global model (GM).

[0236] At this time, the global parameter can be derived using various methods, such as deriving an average value of multiple received local parameters or applying different ratios to each local parameter, but the present invention is not limited thereto.

[0237] Meanwhile, the processor (230) can use the anomaly detection module (ADM) loaded in the memory (240) to determine whether there is an anomaly in the user's newly input data input to the local device (100) or in the user's financial transaction currently in progress. That is, the anomaly detection module (ADM) determines whether there is an anomaly in the user data based on the output data derived using the local model (LM) updated using the global parameters in each local device (100), and can determine whether user authentication or anomaly transaction has occurred based on this. A detailed description thereof will be described later with reference to FIG. 20.

[0238] Below, we will examine in detail the operation of a resource-based federated learning method according to several other embodiments of the present invention.

[0239]

[0240] Figure 18 is a flowchart illustrating a resource-based federated learning method according to several other embodiments of the present invention. Figure 19 is a block diagram illustrating a process for deriving global parameters according to several other embodiments of the present invention. For convenience of explanation, the resource-based federated learning method according to several other embodiments of the present invention will be described below as an example in which the server (200) or the processor (230) is used as the execution entity. In addition, the following description will omit any overlapping content with the aforementioned embodiments of the present invention and focus on the differences.

[0241] Referring to FIGS. 18 and 19, the server (200) determines the hardware information of each local device (100a, 100b) or the size of a pre-stored dataset (S1100). Here, the hardware information may refer to a performance indicator of each local device (100a, 100b), and the pre-stored dataset may refer to the amount of data that each local device (100a, 100b) has pre-stored.

[0242] Next, the server (200) determines the size of the personalized model parameter to be applied to the personalized model (PM) of each local device (100a, 100b) based on the hardware information of each local device (100a, 100b) or the size of the pre-stored dataset (S1200). For example, the server (200) determines the size of the first personalized model parameter (PM) based on the hardware information of the first local device (100a) or the size of the pre-stored dataset. ) and determines the first personalized model parameter ( based on the hardware information of the second local device (100b) or the size of the pre-stored dataset. ) can be determined.

[0243]

[0244] At this time, the personalized model parameters may be determined for each local device (100a, 100b) using a predefined function, or may be determined by comparing performance indicators derived based on the size of the dataset or hardware information for each local device (100a, 100b).

[0245] In other words, the server (200) can determine personalized model parameters based on the size or performance indicator of the dataset of each local device (100a, 100b) (i.e., using an absolute standard) using a predefined function (e.g., a step function), or can relatively calculate personalized model parameters by comparing the size or performance indicator of the dataset for each local device (100a, 100b) with each other.

[0246] Next, the server (200) determines the size of each personalized model parameter ( , ) can be transmitted to each local device (100a, 100b).

[0247] Next, the server (200) provides personalized model parameters ( , ) is applied to the local parameters for the local model (LM) learned on each local device (100a, 100b). , ) are respectively received (S1300). Since the description thereof has been described above with reference to FIGS. 4 to 8, detailed description thereof is omitted.

[0248] Next, the server (200) receives a plurality of local parameters ( , ) based on global parameters ( ) is derived (S1400). Since the description thereof has been described above with reference to Fig. 9, detailed descriptions are omitted.

[0249] Next, the server (200) derives the global parameters ( ) is transmitted to each local device (100a, 100b) (S1500).

[0250] Next, the server (200) sets the global parameter ( ) performs user authentication or anomaly detection for new user data based on the output value of the local model (LM) applied (S1600).

[0251] Anomaly detection operations according to some other embodiments of the present invention will be described below with reference to FIG. 20.

[0252]

[0253] Figure 20 is a flowchart illustrating anomaly detection operations and corresponding service provision operations using a federated-learned local model according to several other embodiments of the present invention. For convenience of explanation, a specific local device (100a) and server (200) will be used as examples below.

[0254] Referring to FIG. 20, a local device (100a) can provide a financial service provided by a server (200) to a user (P). The user (P) can use the financial service provided by the server (200) through the local device (100a).

[0255] A server (200) may be an entity that manages multiple user accounts and provides financial services, and a user (P) may utilize a specific user account among the multiple user accounts to access related financial services. In this case, the user (P) may be the original user of a specific user account, but may also be an intruder attempting to use the user account without authorization.

[0256] Accordingly, the local device (100a) may request user authentication to verify whether the user (P) has the authority to use the user account. That is, the local device (100a) may request user authentication from the user (P), and if the user authentication is successfully performed based on the input data entered by the user, the local device (100a) may provide the user (P) with financial services related to the specific user account.

[0257] At this time, the local device (100a) can display an interface requesting authentication information on the screen and receive input from the user (P) through an input / output device (not shown) equipped in the local device (100a). Here, the input / output device may be at least one of a camera, a pad, a keyboard, a mouse, a touchpad, a touchscreen, and a display device, but the present invention is not limited thereto.

[0258] Next, the local device (100a) inputs input data (i.e., new user data) based on the input of the user (P). ) and generate the generated input data ( ) can be used to perform user authentication. At this time, the local device (100a) can be configured to execute the federated learning module (FLM) in an on-device manner.

[0259] Here, the federated learning module (FLM) may include a local model (LM) and a personalized model (PM) that have been pre-trained through the aforementioned federated learning method. Accordingly, the local device (100a) inputs input data ( ) and the output of the local model (LM) as the output of the federated learning module (FLM) (e.g., the first vector value mentioned above ( )) or the output of the personalized model (PM) (e.g., the first output value mentioned above ( )) is transmitted to the server (200).

[0260] Next, the server (200) receives input data ( ) can perform user authentication or anomaly detection.

[0261] Next, the server (200) inputs data ( ) and transmits the result value (ADR) of user authentication or anomaly detection to the local device (100a). At this time, the server (200) can output the result value (ADR) by calculating the similarity between the received output value and a predetermined reference value.

[0262] Next, the local device (100a) receives user data (ADR) from the server (200) if the result value (ADR) is within a predetermined range. ) and can provide financial services (services) related to the user to the user (P).

[0263] Additionally, according to some other embodiments of the present invention, the local device (100a) may be configured to allow the federated learning module (FLM) to additionally perform local learning on the input (i.e., user data) of a newly authorized user (P). At this time, the local device (100a) may collect the input data of the user (P) and perform additional learning on the federated learning module (FLM) using the collected input data and the user authentication result, thereby further enhancing the performance of the federated learning module (FLM). After the learning is completed, the collected user data may be discarded, thereby further enhancing the protection of user privacy and security. In addition, the server (200) may perform federated learning to periodically update global parameters, thereby improving the accuracy of anomaly detection of each local device (100a to 100k).

[0264]

[0265] FIG. 21 is a diagram illustrating a hardware implementation of a local device or global server performing a resource-based federated learning method according to some embodiments of the present invention.

[0266] Referring to FIG. 21, a local device (100) or a global server (200) performing a resource-based federated learning method according to some embodiments of the present invention may be implemented as an electronic device (1000). The electronic device (1000) may include a processor (1010), an input / output device (1020, I / O), a memory (1030, memory), an interface (1040), a storage (1050, storage), and a bus (1060, bus). The processor (1010), the input / output device (1020), the memory (1030), the interface (1040), and / or the storage (1050) may be coupled to each other via a bus (1060). The bus (1060) corresponds to a path through which data is transferred.

[0267] Specifically, the processor (1010) may include at least one of a Central Processing Unit (CPU), a Micro Processor Unit (MPU), a Micro Controller Unit (MCU), a Graphic Processing Unit (GPU), a microprocessor, a digital signal processor, a microcontroller, an application processor (AP), and logic elements capable of performing functions similar thereto.

[0268] The input / output device (1020) may include at least one of a keypad, a keyboard, a touchscreen, and a display device.

[0269] The memory (1030) can load data and / or programs, etc. At this time, the memory (1030) is an operating memory for improving the operation of the processor (1010) and may include high-speed DRAM and / or SRAM. The memory (1030) may include one or more volatile memory devices such as DDR SDRAM (Double Data Rate Static DRAM) and SDR SDRAM (Single Data Rate SDRAM) and / or one or more non-volatile memory devices such as EEPROM (Electrically Erasable Programmable ROM) and flash memory.

[0270] The interface (1040) may perform a function of transmitting data to or receiving data from a communication network. The interface (1040) may be wired or wireless. For example, the interface (1040) may include an antenna or a wired or wireless transceiver.

[0271] Storage (1050) can store and preserve data and / or programs. Storage (1050) can include one or more non-volatile memory devices, such as a solid state drive (SSD), a hard drive, or flash memory. In the present invention, storage (1050) can store a computer program composed of instructions for performing a resource-based federated learning method.

[0272] Alternatively, the local device (100) and global server (200) according to embodiments of the present invention may each be a system formed by connecting multiple electronic devices (1000) to each other via a network. In this case, each module or combination of modules may be implemented as the electronic device (1000). However, the present embodiment is not limited thereto.

[0273] Additionally, the local device (100) or global server (200) may be implemented as at least one of a workstation, a data center, an internet data center (IDC), a direct attached storage (DAS) system, a storage area network (SAN) system, a network attached storage (NAS) system, and a redundant array of inexpensive disks (RAID) system, but the present embodiment is not limited thereto.

[0274] Additionally, the local device (100) or global server (200) can transmit data via a network. The network may include a network based on wired Internet technology, wireless Internet technology, and short-range communication technology. For example, the wired Internet technology may include at least one of a local area network (LAN) and a wide area network (WAN).

[0275] The wireless Internet technology may include, for example, at least one of Wireless LAN (WLAN), Digital Living Network Alliance (DMNA), Wireless Broadband (Wibro), World Interoperability for Microwave Access (Wimax), High Speed ​​Downlink Packet Access (HSDPA), High Speed ​​Uplink Packet Access (HSUPA), IEEE 802.16, Long Term Evolution (LTE), Long Term Evolution-Advanced (LTE-A), Wireless Mobile Broadband Service (WMBS), and 5G NR (New Radio) technologies. However, the present embodiment is not limited thereto.

[0276] Short-range communication technologies may include, for example, at least one of Bluetooth, Radio Frequency Identification (RFID), Infrared Data Association (IrDA), Ultra-Wideband (UWB), ZigBee, Near Field Communication (NFC), Ultra Sound Communication (USC), Visible Light Communication (VLC), Wi-Fi, Wi-Fi Direct, and 5G NR (New Radio). However, the present embodiment is not limited thereto.

[0277] A local device (100) or a global server (200) communicating through a network may comply with technical standards and standard communication methods for mobile communication. For example, the standard communication method may include at least one of GSM (Global System for Mobile communication), CDMA (Code Division Multi Access), CDMA2000 (Code Division Multi Access 2000), EV-DO (Enhanced Voice-Data Optimized or Enhanced Voice-Data Only), WCDMA (Wideband CDMA), HSDPA (High Speed ​​Downlink Packet Access), HSUPA (High Speed ​​Uplink Packet Access), LTE (Long Term Evolution), LTEA (Long Term Evolution-Advanced), and 5G NR (New Radio). However, the present embodiment is not limited thereto.

[0278] The above description is merely an example of the technical idea of ​​the present embodiment, and those skilled in the art will appreciate that various modifications and variations can be made without departing from the essential characteristics of the present embodiment. Therefore, the present embodiments are not intended to limit the technical idea of ​​the present embodiment, but rather to explain it, and the scope of the technical idea of ​​the present embodiment is not limited by these embodiments. The scope of protection of the present embodiment should be interpreted by the claims below, and all technical ideas within a scope equivalent thereto should be interpreted as being included in the scope of rights of the present embodiment.

Claims

1. In a federated learning method performed on a processor of a local device that operates in conjunction with a global server, A step of determining the size of a personalized model parameter to be applied to a personalized model of the local device based on hardware information of the local device or the size of a pre-stored dataset; A step of applying the personalized model parameters of the determined size to the personalized model and training a local model of the local device using the personalized model; A step of transmitting local parameters for weights of a neural network included in the local model to the global server and receiving global parameters derived based on the local parameters from the global server; and A step of applying the global parameters to the local model and deriving output values ​​for new user data using the local model. Resource-based federated learning method.

2. In paragraph 1, The above personalized model includes an input layer, an output layer, and at least one hidden layer disposed between the input layer and the output layer, The size of at least one hidden layer varies depending on the hardware information of the local device or the size of the pre-stored dataset. Resource-based federated learning method.

3. In paragraph 1, The above personalized model parameters are: Derived using a predefined function based on the size of the dataset pre-stored on the local device, or Including that it is derived using a predetermined function based on the performance indicator of the local device derived based on the hardware information. Resource-based federated learning method.

4. In paragraph 3, The size of the above dataset is determined by the number of users or financial data related to table data pre-stored in a database linked to the local device, The performance indicator of the local device is determined by the amount of computation that the local device can process per unit time. Resource-based federated learning method.

5. In paragraph 1, The step of training the above local model is: A step of applying user data to the local model and receiving a first vector value as an output of the local model; A step of applying the first vector value to the first personalized model and calculating the first loss value based on the first output value, which is the output of the first personalized model; A step of generating augmented data for the user data and applying it to the local model, and receiving a second vector value as an output of the local model; A step of applying a synthetic vector calculated based on the second vector value and the feature vector to the second personalized model, and calculating a second loss value based on the second output value, which is the output of the second personalized model; and A step of training the local model using the first loss value and the second loss value that are produced. Resource-based federated learning method.

6. In paragraph 5, The first personalized model and the second personalized model include an input layer, an output layer, and at least one hidden layer disposed between the input layer and the output layer, In at least one of the first personalized model and the second personalized model, the personalized model parameter of the determined size is applied to the at least one hidden layer. Resource-based federated learning method.

7. In paragraph 5, The above user data includes images or financial transaction data related to the user collected through the local device, The augmented data includes data that rotates the user data or transforms a portion of the user data. Resource-based federated learning method.

8. In paragraph 5, The above feature vector includes a vector value output from the pre-learned model by inputting public data into the pre-learned model. Resource-based federated learning method.

9. In paragraph 5, The step of deriving the output value for the above new user data is: A step of applying new user data to the local model to which the global parameters are applied, and receiving a first vector value as an output of the local model; A step of applying the first vector value to the first personalized model and receiving a first output value as an output of the first personalized model; and A step of applying the first output value to an anomaly detection module and determining whether the new user data is abnormal based on the output of the anomaly detection module. Resource-based federated learning method.

10. In paragraph 1, The step of training the above local model is: A step of applying user data to the local model and receiving a first vector value as an output of the local model; A step of calculating a first loss value based on the first vector value; A step of generating augmented data for the user data and applying it to the local model, and receiving a second vector value as an output of the local model; A step of applying a synthetic vector calculated based on the second vector value and the feature vector to the personalized model, and calculating a second loss value based on the second output value, which is the output of the second personalized model; and A step of training the local model using the first loss value and the second loss value that are produced. Resource-based federated learning method.

11. In paragraph 10, The above personalized model includes an input layer, an output layer, and at least one hidden layer disposed between the input layer and the output layer, In the above personalized model, the personalized model parameter of the determined size is applied to the at least one hidden layer. Resource-based federated learning method.

12. In paragraph 10, The step of deriving the output value for the above new user data is: A step of applying new user data to the local model to which the global parameters are applied, and receiving a first vector value as an output of the local model; and A step of applying the first vector value to an anomaly detection module and determining whether the new user data is abnormal based on the output of the anomaly detection module. Resource-based federated learning method.

13. In a federated learning method performed on a processor of a global server that operates in conjunction with multiple local devices, A step of determining and transmitting the size of each personalized model parameter for the plurality of local devices based on hardware information of the plurality of local devices or the size of a pre-stored dataset; A step of receiving local parameters of a local model learned in each of the local devices using a personalized model to which the personalized model parameters are applied, from each of the plurality of local devices; A step of deriving a global parameter based on a plurality of local parameters received from the plurality of local devices; a step of transmitting the derived global parameters to each of the plurality of local devices; and A step of receiving an output value of a local model to which the global parameter is applied from a specific local device and detecting anomalies in new user data generated from the specific local device based on the output value. Resource-based federated learning method.

14. In paragraph 13, The step of determining and transmitting the size of the above personalized model parameters is: It is determined by comparing the performance indicators derived from the size of the dataset for the plurality of local devices or the hardware information of the plurality of local devices. Resource-based federated learning method.

15. In paragraph 14, The size of the above dataset is determined by the number of financial data related to table data pre-stored in a database linked to the local device, The performance indicator of the local device is determined by the amount of computation that the local device can process per unit time. The size of the above personalized model parameter is determined to be proportional to the number of financial data or the amount of computation for the plurality of local devices. Resource-based federated learning method.

16. In paragraph 13, The step of determining and transmitting the size of the above personalized model parameters is: A step of determining the size of the personalized model parameter using a predetermined function based on the size of the dataset pre-stored in the local device; or A step of determining the size of the personalized model parameter using a predetermined function based on the performance indicator of the local device derived based on the hardware information. Resource-based federated learning method.

17. In paragraph 13, The steps for performing the above anomaly detection are: Including a step of controlling to provide a service corresponding to the new user data on the specific local device when the output value is compared with a predetermined reference value and a predetermined condition is satisfied. Resource-based federated learning method.

18. Processor; a memory for loading a computer program executed by the processor; and Including an interface for exchanging data generated during the execution of the above computer program with a global server, The above computer program, A step of determining the size of a personalized model parameter to be applied to a personalized model of the local device based on hardware information of the local device or the size of a pre-stored dataset; A step of applying the personalized model parameters of the determined size to the personalized model and training a local model of the local device using the personalized model; A step of transmitting local parameters for weights of a neural network included in the local model to the global server and receiving global parameters derived based on the local parameters from the global server; and A step of applying the global parameters to the local model and deriving output values ​​for new user data using the local model. Local device.

19. In paragraph 18, The above personalized model includes an input layer, an output layer, and at least one hidden layer disposed between the input layer and the output layer, A local device in which the size of at least one hidden layer varies depending on hardware information of the local device or the size of a pre-stored dataset.

20. Processor; a memory for loading a computer program executed by the processor; and Including an interface for exchanging data generated during the execution of the above computer program with multiple local devices, The above computer program, A step of determining and transmitting the size of each personalized model parameter for the plurality of local devices based on hardware information of the plurality of local devices or the size of a pre-stored dataset; A step of receiving local parameters of a local model learned in each of the local devices using a personalized model to which the personalized model parameters are applied, from each of the plurality of local devices; A step of deriving a global parameter based on a plurality of local parameters received from the plurality of local devices; a step of transmitting the derived global parameters to each of the plurality of local devices; and A step of receiving an output value of a local model to which the global parameter is applied from a specific local device and detecting anomalies in new user data generated from the specific local device based on the output value. Server.

21. A computer-readable recording medium having recorded thereon a program capable of executing the method described in any one of paragraphs 1 to 17.

Images