Federated learning mlops system

Abstract

The present disclosure relates to an operating method of federated learning MLOps, which may comprise the steps of: receiving, through a pipeline of a federated learning MLOps system, a user input related to a global artificial neural network model; detecting one or more edge devices connected to the federated learning MLOps system; transmitting the global artificial neural network model to the one or more edge devices; receiving weights from the one or more edge devices; and updating the global artificial neural network model on the basis of the weights.

Description

Federated Learning MLOPS System

[0001] The following examples relate to a federated learning MLOps system and its operation method, and more specifically, to a federated learning MLOps system that supports the creation of automated artificial intelligence workflows.

[0002] Conventional MLOps platforms provide convenient and automated methods for building and operating AI, targeting non-experts without specialized knowledge in AI and computer systems.

[0003] However, these platforms require users to 1) understand the type, meaning, and usability of their data, 2) plan a target AI service based on the data, and 3) select the type of AI model to be utilized in the service before using the platform.

[0004] This approach is still perceived as very difficult not only for those unfamiliar with AI, but also for those unfamiliar with data and IT, and increases the barrier to entry for utilizing MLOps platforms.

[0005] A method of operating a federated learning MLOps system according to one embodiment may include receiving a user input related to a global artificial neural network model through a pipeline of the federated learning MLOps system, detecting one or more edge devices connected to the federated learning MLOps system, transmitting the global artificial neural network model to the one or more edge devices, receiving weights from the one or more edge devices, and updating the global artificial neural network model based on the weights.

[0006] The method may further include building or updating a pipeline based on the user input and the one or more edge devices.

[0007] The step of building or updating the pipeline may further include the step of providing the user with an interface for checking tasks performed by nodes within the pipeline and the step of providing an interface for modifying detailed settings of each of the nodes.

[0008] The step of detecting one or more edge devices may include a step of checking the performance of the edge devices and detecting edge devices suitable for the user input.

[0009] The step of receiving the above weights may include a step of measuring the reliability of the weight of each of the edge devices based on the user input, and a step of selecting weights to update the global artificial neural network model based on the reliability.

[0010] The step of selecting the above weights may include a step of assigning a weight to each of the weights based on the reliability.

[0011] The one or more edge devices receive the global artificial neural network model from the federated learning MLOps system, and generate or update a local artificial neural network model capable of performing learning with its own data collected according to the goal of the task, and when the local artificial neural network model completes learning with its own data, the local artificial neural network model can transmit the weights of the local artificial neural network model to the federated learning MLOps system.

[0012] The step of updating the global artificial neural network model may include the step of evaluating the performance of the global artificial neural network model based on the user input and the weights.

[0013] The step of receiving the user input may include a step of receiving, from the user, data on a task to be performed on the edge devices and conditions for selecting edge devices to which the global artificial neural network model is to be applied.

[0014] A method of operating an edge device according to one embodiment may include a step of receiving a global artificial neural network model from a central server, a step of collecting data related to a task to be performed by the electronic device and training the global artificial neural network model into a local artificial neural network model, and a step of checking a status of the central server and transmitting weights of the local artificial neural network model for which training has been completed to the central server based on an instruction from the central server.

[0015] A server according to one embodiment may include a communication unit for communicating with an edge device and a user terminal, a processor, and a memory for storing instructions, wherein the instructions, when executed by the processor, cause the server to receive user input related to a global artificial neural network model through a pipeline of a federated learning MLOps system, detect one or more edge devices connected to the federated learning MLOps system, transmit the global artificial neural network model to the one or more edge devices, receive weights from the one or more edge devices, and update the global artificial neural network model based on the weights.

[0016] An edge device according to one embodiment may include a communication unit that communicates with a central server, a processor that runs an artificial intelligence service, and a memory that stores instructions, wherein the instructions, when executed by the processor, cause the edge device to receive a global artificial neural network model from the central server, collect data related to a task to be performed by the electronic device, train the global artificial neural network model into a local artificial neural network model, check the status of the central server, and transmit weights of the local artificial neural network model for which training has been completed to the central server based on an instruction from the central server.

[0017] Figure 1 is a flowchart illustrating an operation method of a federated learning MLOps system according to one embodiment.

[0018] FIG. 2 is a block diagram schematically illustrating a central server and an edge device according to one embodiment.

[0019] Figure 3 is a schematic flowchart for explaining the operation process of a federated learning MLOps system according to one embodiment.

[0020] FIG. 4 is a diagram illustrating an example of a pipeline according to one embodiment.

[0021] FIG. 5 is a block diagram illustrating an electronic device according to one embodiment.

[0022] Specific structural or functional descriptions of the embodiments are disclosed for illustrative purposes only and may be modified and implemented in various forms. Therefore, the actual implementation is not limited to the specific embodiments disclosed, and the scope of this specification includes modifications, equivalents, or alternatives within the technical concepts described in the embodiments.

[0023] Although terms such as "first" or "second" may be used to describe various components, these terms should be interpreted solely to distinguish one component from another. For example, a first component may be referred to as a second component, and similarly, a second component may also be referred to as a first component.

[0024] When it is said that a component is "connected" to another component, it should be understood that it may be directly connected or connected to that other component, but there may also be other components in between.

[0025] Singular expressions include plural expressions unless the context clearly dictates otherwise. In this specification, the terms "comprises" or "has" should be understood to indicate the presence of a described feature, number, step, operation, component, part, or combination thereof, but not to exclude the possibility of the presence or addition of one or more other features, numbers, steps, operations, components, parts, or combinations thereof.

[0026] Unless otherwise defined, all terms used herein, including technical or scientific terms, have the same meaning as commonly understood by a person of ordinary skill in the art. 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 explicitly defined herein.

[0027] Hereinafter, embodiments will be described in detail with reference to the attached drawings. In the description with reference to the attached drawings, identical components are assigned the same reference numerals regardless of the drawing numbers, and redundant descriptions thereof will be omitted.

[0028]

[0029] Figure 1 is a flowchart illustrating an operation method of a federated learning MLOps system according to one embodiment.

[0030] The operations of FIG. 1 may be performed in the order and manner illustrated, but the order of some operations may be changed or some operations may be omitted without departing from the spirit and scope of the illustrated embodiment. Multiple operations illustrated in FIG. 1 may be performed in parallel or simultaneously.

[0031] For convenience of explanation, steps (110 to 150) are described as operating a federated learning MLOps system provided by the central server (200) illustrated in FIG. 2. However, these steps (110 to 150) may be utilized via any other suitable electronic device and within any suitable system.

[0032] A federated learning MLOps system according to one embodiment may include a central server (200) and one or more edge devices (250).

[0033] MLOps, a combination of machine learning and operations, refers to the maintenance, management, and monitoring of artificial neural network models to ensure their continuous and stable deployment in a production environment. MLOps integrates the development and operation of artificial neural network models, enabling automated maintenance, management, and operation of ML systems. MLOps encompasses not only the development of artificial neural network models, but also the entire AI lifecycle, from data collection and analysis to training and deployment. MLOps fosters collaboration among experts from various fields to ensure the efficient and effective development, deployment, and maintenance of artificial neural network models.

[0034] For example, MLOps can create a pipeline that automates the development stages of artificial neural network models, including data collection, preprocessing, training, validation, and deployment. MLOps can integrate version control and experiment tracking for artificial neural network models, enabling management and comparison of different versions. MLOps can utilize continuous integration (CI) / continuous deployment (CD) methods for continuous testing, integration, and deployment of artificial neural network models. Furthermore, MLOps can continuously monitor models after deployment to ensure they perform as expected. MLOps can also handle large-scale data.

[0035] Conventional MLOps platforms offer users a convenient AI development environment by providing effective GUIs and pipeline-based UIs. However, for users with little AI or IT expertise, these UIs can feel overwhelming and complex.

[0036]

[0037] FIG. 2 is a block diagram schematically illustrating a central server (200) and an edge device according to one embodiment.

[0038] A federated learning MLOps system according to one embodiment may be provided to users by a central server (200).

[0039] A user can access a central server (200) through a user terminal on which an application is installed. The central server (200) can serve as a service platform that provides a federated learning MLOps system service. A user can create an account for the federated learning MLOps system service by signing up for the federated learning MLOps system service provided by the server through the application. The central server (200) can be connected to the terminal through a network. Here, the network can include the Internet, one or more local area networks, wire area networks, cellular networks, mobile networks, other types of networks, or a combination of these networks.

[0040] A user refers to a subject who receives services from a federated learning MLOps system through a user terminal, and may be referred to as a client, customer, etc. In one embodiment, a user terminal is a device that receives a predetermined command from a user and executes a corresponding operation, and may be a digital device that includes an audio output function, a wired / wireless communication function, or other functions. In one embodiment, a terminal may be a concept that includes all digital devices equipped with a memory means and a microprocessor and computing power, such as a tablet PC, a smartphone, a personal computer (e.g., a laptop computer, etc.), a smart TV, a mobile phone, a navigation system, a web pad, a PDA, a workstation, etc.

[0041] According to one embodiment, a user terminal may refer to any user device capable of installing and executing an application related to the Federated Learning MLOps system. At this time, the user terminal may perform overall service operations, such as configuring service screens, entering data, transmitting and receiving data, and storing data, under the control of the application. The application may be implemented for use in both PC and mobile environments, and may be implemented as an independently operating program or configured as an in-app of a specific application to enable operation on said specific application. The user terminal may provide an interface to the user. The interface may be provided by the user terminal itself. For example, it may be provided by the operating system (OS) of the terminal or by an application installed on the user terminal. Furthermore, the interface may be provided by a server, and the user terminal may simply receive and display the interface provided by the server.

[0042] In step (110), the central server (200) may receive user input related to a global artificial neural network model through a pipeline of the federated learning MLOps system. The federated learning MLOps system may receive, from a user, data on tasks to be performed on edge devices (250) and conditions for selecting edge devices (250) to which the global artificial neural network model will be applied. For example, the federated learning MLOps system may receive an input from a user to create or update an artificial neural network model related to medical services. In this case, the federated learning MLOps system may receive a user input requesting to select edge devices specialized in "cancer" as a condition for selecting edge devices (250).

[0043] According to one embodiment, a global artificial neural network model may refer to a global neural network model that a user wishes to build. In a federated learning MLOps system according to one embodiment, a pipeline may refer to a set of automated processes designed to streamline and manage the lifecycle of an artificial neural network model. This may include everything from data collection and preprocessing to model training, validation, deployment, and monitoring. An MLOps pipeline may play a role in maintaining efficiency, reproducibility, and scalability in an artificial neural network model training project.

[0044] For example, a user may be unfamiliar with neural network types such as CNNs, RNNs, and GANs. In this case, instead of directly inputting an RNN or LSTM, the user can manipulate a pre-generated pipeline of Federated Learning MLOps to create and update a global artificial neural network model that performs the desired task.

[0045] In step (120), the central server (200) can detect one or more edge devices (250) connected to the federated learning MLOps system. The edge devices (250) are not limited to the three edge devices (250) illustrated in FIG. 2, but may be comprised of multiple edge devices (250).

[0046] According to one embodiment, a central server (200) may be a server installed in a central organization capable of controlling or monitoring edge devices (250) installed in multiple organizations. The central server (200) may be connected to each of the edge devices (250) via a network (not shown). The edge devices (250) may be electronic devices (or individual servers) equipped with a network environment installed in organizations with bases in multiple regions. The edge devices (250) may each learn and build a local artificial neural network model, and may share or transmit / receive the artificial neural network model via a network connected to the central server (200).

[0047] In a federated learning MLOps system according to one embodiment, the central server (200) can query the performance of edge devices (250) to detect edge devices (250) suitable for user input. For example, the central server (200) can check the status of the edge device through CPU usage, response time, network latency, etc. The data processing capability of the edge device can be measured, and whether the edge device can perform the user input based on the workload of the edge device can be determined.

[0048] In step (130), the central server (200) can transmit a global artificial neural network model to one or more edge devices (250).

[0049] According to one embodiment, an "organization" may include a medical institution, financial institution, healthcare service company, personal information management agency, public institution, military institution, etc. that operates an artificial neural network model through an edge device. Below, for convenience of explanation, "organization" is described based on a medical institution (e.g., a hospital), but "organization" is not limited to a medical institution. An organization that operates an artificial neural network model service may have a group of GPU servers for local artificial neural network model training and may operate base institutions in multiple regions to share and provide services with local artificial neural network models among the institutions. Hereinafter, a service provided by an organization based on an artificial neural network model is referred to as an artificial intelligence service. An organization may provide an artificial intelligence service by building a different local artificial neural network model for each individual base based on the data of each organization.

[0050] According to one embodiment, edge devices (250) may receive a global artificial neural network model from a federated learning MLOps system provided by a central server (200), and may create or update a local artificial neural network model capable of performing learning with its own data collected according to the objective of the task. When learning on its own data is completed in the local artificial neural network model, the edge devices (250) may transmit the weights of the local artificial neural network model to the central server (200) providing the federated learning MLOps system.

[0051] In step (140), the central server (200) can receive weights from one or more edge devices (250).

[0052] Updating an artificial neural network model requires centralizing all data collected from each organization and training the model using a large volume of data. However, since data export is prohibited in organizations with high data security levels, model training can only be done with limited data within each organization. In other words, organizations with multiple locations cannot provide identical AI services across all locations due to data export issues. Consequently, improving AI model performance can be difficult when developing with limited data from a single organization. For example, if a unique case occurs at Organization A, the advanced AI service developed using this data can only be operated at Organization A, and Organization B cannot utilize the service.

[0053] Accordingly, the central server (200) can receive the weights of the local artificial neural network model of the edge device itself after the local artificial neural network model has completed training, rather than the data from the edge devices (250). At this time, the central server (200) can measure the reliability of the weights of each edge device (250) based on user input. The central server (200) can select weights to update the global artificial neural network model based on the reliability. At this time, the central server (200) can assign a weight to each weight based on the reliability. For example, assume that the edge device is a device capable of operating a local artificial neural network model installed in a medical institution. If the user input is to create or update a global artificial neural network model specialized in "cancer," the reliability of weights received from a medical institution with a "cancer center" or a "cancer" specialized hospital can be assigned a high reliability. On the other hand, the reliability of weights received from an orthopedic hospital, etc., can be assigned a low reliability. After this, the central server (200) can assign high weights to weights with high reliability and low weights to weights with low reliability based on reliability.

[0054] In step (150), the central server (200) can update the global artificial neural network model based on the weights. The central server (200) can evaluate the performance of the global artificial neural network model based on the user input and the weights. For example, a model evaluation system that independently verifies the performance of the updated global artificial neural network model can be built, and a test task can be performed based on the received weights and data input by the user. At this time, if the output result of the global artificial neural network model falls short of the result requested by the user or is not the result directly desired by the user is input to the federated learning MLOps system, the federated learning MLOps system can re-execute the update to improve the performance of the global artificial neural network model.

[0055] As will be described in detail with reference to FIG. 3 below, the central server (200) can receive the weights of local artificial neural network models for which learning has been completed from each edge device (250), update the global artificial neural network model, and transmit the updated global artificial neural network model back to the edge devices (250).

[0056]

[0057] Figure 3 is a schematic flowchart for explaining the operation process of a federated learning MLOps system according to one embodiment.

[0058] The description with reference to FIG. 1 and FIG. 2 can be equally applied to FIG. 3, and overlapping content can be omitted.

[0059] A federated learning MLOps system according to one embodiment may be provided by a central server (200). The central server (200) according to one embodiment may perform an edge status check operation (201) to check the status of edge devices (250). The central server (200) that has checked the status of edge devices (250) may perform an edge sampling operation (203) to select edge devices that are suitable for user input conditions, etc. among the edge devices (250). The central server (200) may transmit a global artificial neural network model to the sampled edge devices (250). Thereafter, the central server (200) may receive weights from the edge devices (250) according to the user's input or operation sequence in the federated learning MLOps system and perform a weight collation operation (205). The central server (200) may use the collated weights to update (207) the global artificial neural network model. The central server (200) can repeatedly perform the aforementioned operations (201 to 207) to maintain the global artificial neural network model up to date and generate a global artificial neural network model suitable for the user's input and conditions. The global artificial neural network model thus generated can be transmitted to edge devices (250), so that the edge devices (250) can utilize the improved local artificial neural network model to provide artificial intelligence services.

[0060] According to one embodiment, edge devices (250) can independently collect (251) their own data for a target task. The edge devices (250) can learn (253) the global artificial neural network model and the collected data received from the central server (200) to update or create a local artificial neural network model. The edge devices (250) can check (255) the status of the central server (200) and transmit the weights of the local artificial neural network model to the central server (200). In a federated learning MLOps system, the edge devices (250) can repeatedly perform the above-described operations (251 to 253) to continuously receive an updated global artificial neural network model. In conclusion, the output of an artificial intelligence service can be improved because a global artificial neural network model based on the weights of data learned from other edge devices (250) as well as its own data can be utilized even in edge devices with limited data. That is, edge devices (250) can continuously update local artificial neural network models through the federated learning MLOps system, thereby providing improved artificial intelligence services (257).

[0061]

[0062] FIG. 4 is a diagram illustrating an example of a pipeline according to one embodiment.

[0063] Referring to FIG. 4, in a federated learning MLOps system according to one embodiment, a central server (200) can build or update a pipeline based on user input and one or more edge devices (250). The federated learning MLOps system can build a constructed global artificial neural network model into a pipeline-based UI and provide it to the user.

[0064] A federated learning MLOps system can provide users with an interface that allows them to view the tasks performed by nodes within the pipeline. For example, the interface could be a block-based UI for data preprocessing, model training, and model deployment.

[0065] A federated learning MLOps system can provide an interface for modifying detailed settings for each node. For example, this could include a settings menu, a status check menu, and a notification menu for edge devices.

[0066] According to one embodiment, the pipeline UI may include a resource preparation UI, a data cleansing UI, a model training UI, and a model deployment UI. However, Figure 3 is merely an example illustrating a pipeline-based UI and is not necessarily limited thereto.

[0067] Federated Learning MLOps systems can perform easy AI learning. For example, they can provide a GUI environment where data-customized AI models can be selected and trained with just a click.

[0068] Federated learning MLOps systems can reduce model building time and costs. For example, federated learning MLOps systems can provide high-performance AI models for language, visual, and emotional analysis, reducing the time and cost of AI development.

[0069] Federated learning MLOps systems can operate automated AI. For example, federated learning MLOps systems can support automatic retraining of service operation data, enabling advanced, service-tailored AI operations.

[0070] Federated learning MLOps systems can provide efficient model training. For example, federated learning MLOps systems can provide distributed node processing technology that enables distributed learning and integrated memory capabilities for high-capacity model training.

[0071] Federated learning MLOps systems can provide efficient training schedule management. For example, federated learning MLOps systems can automatically sequentially perform training with various parameter settings and accelerate inter-GPU communication to achieve rapid training.

[0072] The Federated Learning MLOps system can provide a convenient development environment. For example, it can support integration with existing development environments and tuning of custom code.

[0073] Federated learning MLOps systems can provide large-scale resource monitoring. For example, a federated learning MLOps system can monitor GPU resource operation status and manage network interfaces between GPU servers.

[0074] A federated learning MLOps system can provide purpose-specific GPU management. For example, a federated learning MLOps system can create workspaces to allocate GPU resources and efficiently manage the allocated GPU resources.

[0075] Federated learning MLOps systems can provide rapid fault detection. For example, a federated learning MLOps system can support rapid fault detection and accurate root cause analysis through real-time status monitoring.

[0076]

[0077] FIG. 5 is a block diagram illustrating an electronic device according to one embodiment.

[0078] One or more blocks and combinations of blocks of FIG. 5 may be implemented by a special-purpose hardware-based computer performing a specific function, or by a combination of special-purpose hardware and computer instructions. The descriptions made with reference to FIGS. 1 through 4 may be equally applicable to FIG. 5 . For example, an electronic device (500) (e.g., a central server (200)) according to one embodiment may include a federated learning MLOps system (100).

[0079] As shown in FIG. 5, the electronic device (500) may include a memory (510) and a processor (520). The electronic device (500) may further include a communication module, and the communication module may include a transmitter and a receiver.

[0080] An electronic device (500) according to one embodiment may include a memory (510) and a processor (520) connected to the memory (510) via a system bus or other suitable circuitry.

[0081] The electronic device (500) may store program code in memory (510). In one embodiment, the memory (510) may include one or more physical memory devices, such as local memory or one or more bulk storage devices. In this case, the local memory may include random access memory (RAM) or other volatile memory devices commonly used while actually executing the program code. The bulk storage device may be implemented as a hard disk drive (HDD), a solid state drive (SSD), or other non-volatile memory device.

[0082] As the executable program code stored in the memory (510) is executed by the electronic device (500), the processor (520) may perform various operations described in the present disclosure. For example, the memory (510) may store program code for causing the processor (520) to perform one or more operations described in FIGS. 1 to 4.

[0083] Depending on the specific type of device being implemented, the electronic device (500) may include fewer components than those illustrated or additional components not illustrated in FIG. 5. Additionally, one or more of the components may be incorporated into, or otherwise form part of, another component.

[0084] A processor (520) according to one embodiment is a hardware configuration that performs overall control functions for controlling the operations of an electronic device (500). For example, the processor (520) may control the electronic device (500) overall by executing programs stored in a memory (510) within the electronic device (500). The processor (520) may be implemented as a central processing unit (CPU), a graphics processing unit (GPU), an application processor (AP), a neural processing unit (NPU), or the like, provided within the electronic device (500), but is not limited thereto.

[0085] The processor (520) can receive user input related to a global artificial neural network model through a pipeline of a federated learning MLOps system, detect one or more edge devices connected to the federated learning MLOps system, transmit the global artificial neural network model to the one or more edge devices, receive weights from the one or more edge devices, and update the global artificial neural network model based on the weights.

[0086]

[0087] The embodiments described above may be implemented using hardware components, software components, and / or a combination of hardware components and software components. For example, the devices, methods, and components described in the embodiments may be implemented using a general-purpose computer or a special-purpose computer, such as, for example, a processor, a controller, an arithmetic logic unit (ALU), a digital signal processor, a microcomputer, a field programmable gate array (FPGA), a programmable logic unit (PLU), a microprocessor, or any other device capable of executing instructions and responding to them. The processing device may execute an operating system (OS) and software applications running on the operating system. Furthermore, the processing device may access, store, manipulate, process, and generate data in response to the execution of the software. For ease of understanding, the processing device is sometimes described as being used alone; however, one of ordinary skill in the art will recognize that the processing device may include multiple processing elements and / or multiple types of processing elements. For example, a processing unit may include multiple processors, or a processor and a controller. Other processing configurations, such as parallel processors, are also possible.

[0088] Software may include a computer program, code, instructions, or a combination of one or more of these, which may configure a processing device to perform a desired operation or may, independently or collectively, command the processing device. The software and / or data may be permanently or temporarily embodied in any type of machine, component, physical device, virtual equipment, computer storage medium or device, or transmitted signal wave, for interpretation by the processing device or for providing instructions or data to the processing device. The software may also be distributed over networked computer systems and stored or executed in a distributed manner. The software and data may be stored on a computer-readable recording medium.

[0089] The method according to the embodiment may be implemented in the form of program commands that can be executed through various computer means and recorded on a computer-readable medium. The computer-readable medium may include program commands, data files, data structures, etc., alone or in combination, and the program commands recorded on the medium may be those specially designed and configured for the embodiment or may be known and available to those skilled in the art of computer software. Examples of the computer-readable recording medium include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and hardware devices specially configured to store and execute program commands such as ROMs, RAMs, and flash memories. Examples of program commands include not only machine language codes such as those generated by a compiler, but also high-level language codes that can be executed by a computer using an interpreter, etc.

[0090] The hardware devices described above may be configured to operate as one or more software modules to perform the operations of the embodiments, and vice versa.

[0091] Although the embodiments described above have been described with limited drawings, those skilled in the art will appreciate that various technical modifications and variations can be applied based on the described embodiments. For example, appropriate results can still be achieved even if the described techniques are performed in a different order than described, and / or components of the described systems, structures, devices, circuits, etc. are combined or combined in a different manner than described, or are replaced or substituted with other components or equivalents.

[0092] Therefore, other implementations, other embodiments, and equivalents to the claims also fall within the scope of the claims described below.

Claims

1. In terms of the operation method of the federated learning MLOps system, A step of receiving user input related to a global artificial neural network model through a pipeline of the above federated learning MLOps system; A step of detecting one or more edge devices connected to the above federated learning MLOps system; A step of transmitting the global artificial neural network model to one or more edge devices; a step of receiving weights from one or more edge devices; and A step of updating the global artificial neural network model based on the above weights. A method of operating a federated learning MLOps system, comprising:

2. In paragraph 1, A step of building or updating the pipeline based on the user input and the one or more edge devices. A method of operating a federated learning MLOps system, which further includes:

3. In paragraph 2, The steps to build or update the above pipeline are: A step of providing an interface for the user to check the tasks performed by the nodes in the pipeline; and A step for providing an interface that can modify the detailed settings of each of the above nodes. A method of operating a federated learning MLOps system, which further includes:

4. In paragraph 1, The step of detecting one or more edge devices is A step of checking the performance of the above edge devices and detecting edge devices suitable for the above user input. A method of operating a federated learning MLOps system, comprising:

5. In paragraph 1, The step of receiving the above weights is A step of measuring the reliability of the weight of each of the edge devices based on the user input; and A step of selecting weights to update the global artificial neural network model based on the above reliability. A method of operating a federated learning MLOps system, comprising:

6. In paragraph 5, The step of selecting the above weights is A step of assigning weights to each of the weights based on the above reliability. A method of operating a federated learning MLOps system, comprising:

7. In paragraph 1, One or more of the above edge devices By receiving the global artificial neural network model from the above federated learning MLOps system, a local artificial neural network model capable of learning with its own data collected according to the goal of the task is created or updated. A method for operating a federated learning MLOps system, wherein, when the local artificial neural network model completes learning on its own data, the weights of the local artificial neural network model are transmitted to the federated learning MLOps system.

8. In paragraph 1, The steps for updating the above global artificial neural network model are: A step of evaluating the performance of the global artificial neural network model based on the user input and the weights. A method of operating a federated learning MLOps system, comprising:

9. In paragraph 1, The step of receiving the above user input is A step of receiving data on tasks to be performed on the edge devices from the user and conditions for selecting edge devices to which the global artificial neural network model is to be applied. A method of operating a federated learning MLOps system, comprising:

10. In the operating method of the edge device, A step of receiving a global artificial neural network model from a central server; A step of collecting data related to a task to be performed by the electronic device and training the global artificial neural network model into a local artificial neural network model; and A step of checking the status of the central server and transmitting the weight of the local artificial neural network model for which learning has been completed to the central server based on the instructions of the central server. A method of operating an edge device, comprising:

11. A computer program stored in a computer-readable recording medium to execute the method of claim 1 by being combined with hardware.

12. On the server, A communication unit that communicates with an edge device and a user terminal; processor; and Memory that stores instructions Including, The above instructions, when executed by the processor, cause the server to: Receive user input related to the global artificial neural network model through the pipeline of the federated learning MLOps system, Detecting one or more edge devices connected to the above federated learning MLOps system, Transmitting the above global artificial neural network model to one or more edge devices, Receiving weights from one or more edge devices, A server for updating the global artificial neural network model based on the above weights.

13. For edge devices, Communication unit that communicates with the central server; A processor that runs an artificial intelligence service; and Memory that stores instructions Including, The above instructions, when executed by the processor, cause the edge device to: Receive a global artificial neural network model from the central server, By collecting data related to the work to be performed by the above edge device, the global artificial neural network model is trained as a local artificial neural network model, An edge device that checks the status of the central server and, based on instructions from the central server, transmits the weights of the local artificial neural network model for which learning has been completed to the central server.

Images