Method for updating ai model in cloud environment, and electronic apparatus and system for performing same
By generating model-specific information and signing personalized AI models, the method ensures only suitable models are used for updating, addressing the issue of biased data and maintaining AI model performance.
Patent Information
- Application Number
- PCT/KR2026/096855
- Authority / Receiving Office
- WO · WO
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2025-05-12
- Filing Date
- 2026-05-12
- Publication Date
- 2026-11-19
AI Technical Summary
Existing AI models trained on biased or distorted data can degrade the performance of underlying models when used for updates, necessitating a method to exclude unsuitable models during the update process.
A user terminal generates model-specific information based on unique properties, signs a personalized AI model, and transmits it to a server, which determines suitability by comparing parameters and model-specific information to exclude unsuitable models during the update of a base AI model.
Ensures that only suitable AI models are used for updating, maintaining the integrity and performance of the base AI model by excluding biased or distorted models.
Smart Images

Figure KR2026096855_19112026_PF_FP_ABST
Abstract
Description
Method for updating AI models in a cloud environment, electronic devices and systems for performing this.
[0001] The present disclosure relates to a method for updating an AI model in a cloud environment, and more specifically, to a method in which, when a user terminal transmits a personalized AI model generated in an on-device environment to a server, the server selects a personalized AI model to be reflected in the update of a base AI model.
[0002] With the recent advancement of artificial intelligence technology, various AI models, including Large Language Models (LLMs), are being provided in cloud environments. These AI models are generally generated through pre-training and can be optimized by fine-tuning them based on user input.
[0003] For example, a basic AI model provided by the server can be fine-tuned based on user input while running in an on-device environment, thereby generating a personalized AI model that reflects the user's preferences and style. The fine-tuned personalized AI model can then be used by the server to update the basic AI model.
[0004] However, some personalized AI models may be trained on biased data or distorted information, making them unsuitable for updating the underlying AI model on the server. If such unsuitable models are used for updates, there is a possibility that the bias of the underlying AI model will increase or its performance will degrade. Therefore, when updating the underlying AI model using multiple personalized AI models, technology is required to exclude unsuitable models.
[0005] The background technology described above is technical information that the inventor possessed or acquired in the process of deriving the present disclosure, and it cannot necessarily be regarded as prior art disclosed prior to the filing of the present disclosure.
[0006] According to one or more embodiments of the present disclosure, the method may include the step of a user terminal acquiring a base AI model. The base AI model may be acquired from the server. The method may include the step of the user terminal acquiring a personalized AI model by performing fine-tuning on the base AI model based on user data. The user data may be collected during the process of executing the base AI model on the user terminal. The method may include the step of the user terminal generating model-specific information corresponding to the personalized AI model based on the unique properties of the user terminal. The method may include the step of the user terminal performing signing on the personalized AI model using the model-specific information. The method may include the step of the user terminal transmitting the model-specific information and the signed personalized AI model to the server.
[0007] According to one or more embodiments of the present disclosure, a user terminal may include a memory in which a program or at least one instruction is stored and at least one processor operably coupled to said memory. By executing the program or said at least one instruction stored in said memory by said at least one processor, the user terminal obtains a base AI model from a server and obtains a personalized AI model by performing fine-tuning on said base AI model based on user data collected during the execution of said base AI model. said user data may be collected during the execution of said base AI model. By executing a program stored in the memory or at least one instruction, the user terminal can generate model-specific information corresponding to the personalized AI model based on the unique properties of the user terminal, perform signing of the personalized AI model using the model-specific information, and then transmit the model-specific information and the signed personalized AI model to the server.
[0008] According to one aspect of the present disclosure, a system for updating an AI model in a cloud environment comprises a user terminal that provides a base AI model, a server for updating the base AI model, and a UI for using the base AI model. The user terminal may acquire and store the base AI model from the server, acquire a personalized AI model by performing fine-tuning on the base AI model based on user data collected during the process of executing the base AI model, generate model-specific information corresponding to the personalized AI model based on the unique properties of the user terminal, perform signing on the personalized AI model using the model-specific information, and then transmit the model-specific information and the signed personalized AI model to the server.
[0009] According to one aspect of the present disclosure, a computer-readable recording medium may store a program for executing at least one of the embodiments of the disclosed method on a computer.
[0010] According to one aspect of the present disclosure, a computer program may be stored on a medium to perform at least one of the embodiments of the disclosed method on a computer.
[0011] FIG. 1 illustrates a system for providing AI services in a cloud environment according to one embodiment of the present disclosure.
[0012] FIG. 2 illustrates a security execution framework included in a user terminal according to one embodiment of the present disclosure.
[0013] Figure 3 illustrates the operations performed by the user terminal and the server in sequence.
[0014] FIG. 4 illustrates a process in which a user terminal according to one embodiment of the present disclosure generates model-specific information, performs a signature on a personalized AI model using the generated model-specific information, and then transmits it to a server.
[0015] FIG. 5 illustrates detailed information included in model-specific information according to one embodiment of the present disclosure.
[0016] Figure 6 is a diagram illustrating a method for determining whether a personalized AI model is an unsuitable model by comparing the parameters of the personalized AI model and the basic AI model.
[0017] Figure 7 is a diagram illustrating a method for determining whether a personalized AI model is an unsuitable model by comparing parameters between the model after the basic AI model has been additionally trained using a personalized AI model and the basic AI model.
[0018] FIGS. 8 and 9 are drawings for explaining a process in which a server according to one embodiment of the present disclosure determines whether to use a personalized AI model for updating a basic AI model based on model-specific information.
[0019] FIG. 10 is a drawing illustrating the configurations included in a user terminal according to one embodiment of the present disclosure.
[0020] FIGS. 11 to 14 are flowcharts illustrating a method for updating an AI model in a cloud environment according to embodiments of the present disclosure.
[0021] The embodiments described in this disclosure are non-limiting exemplary embodiments, and therefore the disclosure is not limited thereto and can be implemented in various other forms.
[0022] In describing the present disclosure, technical details that are well known in the technical field to which the present disclosure belongs and are not directly related to the present disclosure are omitted. This is intended to convey the essence of the present disclosure more clearly without obscuring it by omitting unnecessary explanations. Furthermore, the terms described below are defined considering their functions within the present disclosure, and these definitions may vary depending on the intentions or practices of the user or operator. Therefore, their definitions should be based on the content throughout this specification.
[0023] For the same reason, some components in the attached drawings have been exaggerated, omitted, or schematically depicted. Additionally, the dimensions of each component do not entirely reflect their actual dimensions. Identical or corresponding components in each drawing have been assigned the same reference numbers.
[0024] The advantages and features of the present disclosure, and the methods for achieving them, will become clear by referring to the embodiments described below in detail together with the accompanying drawings. However, the present disclosure is not limited to the embodiments disclosed below but may be implemented in various different forms. The disclosed embodiments are provided to ensure that the disclosure of the present disclosure is complete and to fully inform those skilled in the art of the scope of the disclosure. An embodiment of the present disclosure may be defined according to the claims. Throughout the specification, the same reference numerals indicate the same components. Furthermore, in describing an embodiment of the present disclosure, if it is determined that a detailed description of a related function or configuration might unnecessarily obscure the essence of the present disclosure, such detailed description is omitted. Additionally, terms described below are defined considering their functions in the present disclosure, and these may vary depending on the intentions or conventions of the user or operator. Therefore, their definitions should be based on the content throughout the specification.
[0025] In one embodiment, each block of the flowcharts and combinations of the flowcharts may be executed by computer program instructions. Computer program instructions may be loaded onto a processor of a general-purpose computer, a computer for special purposes, or other programmable data processing equipment, and the instructions executed through the processor of the computer or other programmable data processing equipment may create means for performing the functions described in the flowchart block(s). Computer program instructions may also be stored in computer-available or computer-readable memory that can be directed toward the computer or other programmable data processing equipment to implement functions in a specific manner, and instructions stored in computer-available or computer-readable memory may produce a manufactured item containing instruction means for performing the functions described in the flowchart block(s). Computer program instructions may also be loaded onto a computer or other programmable data processing equipment.
[0026] Additionally, each block of the flowchart may represent a module, segment, or part of code containing one or more executable instructions for executing a specified logical function(s). In one embodiment, the functions mentioned in the blocks may occur out of order. For example, two blocks shown in succession may be executed substantially simultaneously or in reverse order depending on the function.
[0027] In one embodiment of the present disclosure, the term “part” used may refer to software or hardware components such as a Field Programmable Gate Array (FPGA) or an Application Specific Integrated Circuit (ASIC), and the “part” may perform a specific role. Meanwhile, the “part” is not limited to software or hardware. The “part” may be configured to reside in an addressable storage medium or may be configured to run one or more processors. In one embodiment, the “part” may include components such as software components, object-oriented software components, class components, and task components, as well as processes, functions, attributes, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuits, data, databases, data structures, tables, arrays, and variables. Functions provided through a specific component or a specific “part” may be combined or separated into additional components to reduce their number. Additionally, in one embodiment, the “part” may include one or more processors.
[0028] The meanings of the terms used in the present disclosure are explained below.
[0029] A 'base AI model' may refer to an AI model that is provided in a cloud environment and is pre-trained to be utilized in various AI services. According to one embodiment of the present disclosure, the base AI model may be transmitted from a server operated by a service provider to a user terminal, stored on the user terminal, and then executed in an on-device environment. The base AI model may be composed of various types of AI models, including a generative model.
[0030] In this disclosure, 'basic AI model' may be replaced with terms such as 'common AI model', 'foundation model', 'pretrained model', 'public AI model', or 'original AI model'.
[0031] A 'personalized AI model' can refer to a basic AI model that has been fine-tuned using user data. In other words, a personalized AI model can be a basic AI model extended to be customized for the user.
[0032] According to one embodiment of the present disclosure, a personalized AI model can be generated by fine-tuning a basic AI model based on user input (e.g., a prompt) used during the process of executing a basic AI model in an on-device environment of a user terminal. The personalized AI model can provide a personalized output by reflecting the user's preferences, style, specific response patterns, etc.
[0033] In the present disclosure, 'personalized AI model' may be replaced with terms such as 'private AI model', 'fine-tuned AI model', 'adapted AI model', 'customized AI model', or 'user model'.
[0034] An "unsuitable model" may refer to a personalized AI model that is not suitable for use in updating a base AI model due to being trained on biased data, having distorted information, or other reasons. According to one embodiment of the present disclosure, a server identifies an unsuitable model among personalized AI models received from a plurality of user terminals, and the personalized AI model identified as unsuitable may be excluded when updating the base AI model.
[0035] In this disclosure, 'inadequate model' may be replaced with terms such as 'poisoned model', 'biased model', 'inadequate model', or 'inappropriate model'.
[0036] 'User data' refers to data that includes user input (e.g., prompts), interaction records, and user-related information that can be utilized for fine-tuning AI models. In other words, user data may include user input received during the execution of the underlying AI model in the on-device environment of a user terminal. For instance, when a user utilizes an AI service through a user terminal, they may input a prompt requesting a specific task, and the underlying AI model may perform inference based on this prompt; in this process, the input prompt can be included in the user data.
[0037] In the present disclosure, 'user data' may be replaced with terms such as 'user input', 'input data', or 'user information'.
[0038] A 'device key' refers to a cryptographic key uniquely assigned to a specific terminal, which can be utilized for purposes such as terminal authentication, secure communication, and data signing. According to one embodiment of the present disclosure, the device key may be generated based on the unique characteristics of the hardware of the user terminal. For example, a PUF (Physical Unclonable Function) based key (e.g., CPU ID) may be generated based on the physical characteristics of one or more processors (e.g., CPU chips) included in the user terminal, and a device key may be generated based on the PUF based key. The PUF based key may be used as is as the device key, or the device key may be generated using the PUF based key. The device key may be used when verifying the source of a personalized AI model on a server.
[0039] "Model-specific information" may refer to information for identifying a personalized AI model. According to one embodiment of the present disclosure, model-specific information may be generated based on a terminal key (e.g., CPU ID). For example, model-specific information may be generated by adding other information to the terminal key. Specifically, in addition to the terminal key, information regarding the region and time in which the personalized AI model was generated, information regarding the terminal that generated the personalized AI model, and information regarding the software environment in which the personalized AI model was generated (e.g., TEE ID, instance ID) may be included in the model-specific information. The user terminal may generate model-specific information when the personalized AI model is generated and transmit the model-specific information to a server along with the personalized AI model.
[0040] Embodiments of the present disclosure will be described in detail below with reference to the drawings.
[0041] 1. Overall system for carrying out embodiments of the present disclosure (Fig. 1)
[0042] FIG. 1 illustrates a system for providing AI services in a cloud environment according to one embodiment of the present disclosure. Referring to FIG. 1, the system may include a server (100) and a user terminal (1000).
[0043] A server (100) operated by a service provider that provides AI services may store a pre-trained basic AI model. The basic AI model may consist of various types of AI models, including generative models such as LLM (Large Language Model).
[0044] The user terminal (1000) can download a basic AI model from the server (100) and run it in an on-device environment. The user (1) can use the AI service through the user terminal (1000).
[0045] User data may be collected from the user terminal (1000) during the process of the user (1) using the AI service. User data may refer to data that can be used for fine-tuning the AI model, as previously explained.
[0046] For example, when a user (1) inputs a prompt through a user terminal (1000), a basic AI model running on the user terminal (1000) can perform inference based on the input prompt and output the result through the user terminal (1000). In this process, the input prompt can be collected as user data.
[0047] In addition, user data may also include records of interactions between the user (1) and the user terminal (1000) that occur during the process of the user (1) using the AI service. User data may include all kinds of user-related information that can be used for fine-tuning the basic AI model.
[0048] The user terminal (1000) can generate a personalized AI model optimized for the user (1) by performing fine-tuning on a basic AI model using collected user data. The personalized AI model can provide a personalized output by reflecting the user's (1) preferences, style, specific response patterns, etc.
[0049] When a personalized AI model is generated, the user terminal (1000) can generate model-specific information corresponding to the personalized AI model. The model-specific information may be information for identifying the personalized AI model generated by the user terminal (1000). Accordingly, the model-specific information may be used by the server (100) to verify the source of the personalized AI model or to obtain other information about the personalized AI model (e.g., information about when, where, and by which group the model was created).
[0050] According to one embodiment of the present disclosure, model-specific information may be generated based on unique properties of a user terminal (1000). For example, model-specific information may be generated based on a unique key based on the physical properties of one or more processors included in the user terminal (1000). Accordingly, model-specific information may be used to identify the user terminal (1000) that generated the personalized AI model.
[0051] The specific method for generating model-specific information and the details included in the model-specific information are explained in detail below with reference to other drawings.
[0052] When model-specific information is generated, the user terminal (1000) can use the model-specific information to sign the personalized AI model and transmit the model-specific information and the signed personalized AI model to the server (100).
[0053] The server (100) can update the basic AI model by additionally training the basic AI model stored in the server (100) using the personalized AI model received from the user terminal (1000). The server (100) can receive multiple personalized AI models from multiple terminals, exclude some models that are deemed unsuitable for use during additional training, and update the basic AI model by reflecting the remaining models suitable for additional training.
[0054] In one or more embodiments, the method by which the server (100) determines whether the personalized AI model is suitable for use during additional training is as follows.
[0055] 1) Determine whether the personalized AI model is an unsuitable model
[0056] The server (100) can determine whether a personalized AI model is an unsuitable model by comparing the parameters of the models. According to one embodiment of the present disclosure, the server (100) can determine whether a personalized AI model is an unsuitable model based on the result of comparing the parameters of any one pair of models.
[0057] i) Compare parameters between the personalized AI model and the basic AI model
[0058] ii) Using a personalized AI model, compare parameters between the model after the base AI model is updated (post-update model) and the base AI model (pre-update model).
[0059] The server (100) may determine that the personalized AI model is an unsuitable model if the parameters of the two models differ by more than a certain standard. A large difference in the parameters of the two models means that the basic AI model changes significantly when the personalized AI model is used for additional training. The method by which the server (100) determines whether the parameters of the two models differ by more than a certain standard is as follows.
[0060] First, the server (100) can calculate the difference in parameter values for each corresponding pair of nodes of the two models, calculate the average of the differences calculated for all nodes, and compare the average with a predetermined threshold. If the average is greater than the predetermined threshold, the server (100) can determine that the personalized AI model is an unsuitable model.
[0061] Secondly, the server (100) can calculate the difference in parameter values for each corresponding pair of nodes of the two models, calculate the variance of the difference calculated for all nodes, and compare the variance with a predetermined threshold. If the variance is greater than the predetermined threshold, the server (100) can determine that the personalized AI model is an unsuitable model.
[0062] Thirdly, the server (100) calculates the difference in parameter values for each corresponding pair of nodes of the two models, checks the number of pairs of nodes that have a difference greater than a predetermined value, and if the number of confirmed pairs of nodes is greater than a predetermined threshold, the server (100) can determine that the personalized AI model is an unsuitable model.
[0063] The server (100) can exclude personalized AI models that are determined to be unsuitable models during additional training of the basic AI model.
[0064] 2) Determine whether to use the personalized AI model for additional training based on model-specific information
[0065] If the server (100) discovers at least one personalized AI model corresponding to an unsuitable model according to the method described above, it can determine whether to use the subsequently received personalized AI models for additional learning based on the model-specific information received together.
[0066] Specifically, the server (100) can determine, based on model-specific information, the degree of correlation between a newly received personalized AI model and a personalized AI model previously determined to be an unsuitable model. The server (100) can decide not to use a personalized AI model that has a correlation with a previously determined unsuitable model above a certain standard for updating the basic AI model.
[0067] According to one embodiment of the present disclosure, the server (100) can determine, based on model-specific information, whether a received personalized AI model corresponds to one of the following two types.
[0068] i) Personalized AI model transmitted from a terminal that previously transmitted an unsuitable model
[0069] ii) Personalized AI models transmitted from terminals highly relevant to the terminal that previously transmitted an unsuitable model
[0070] The server (100) may decide not to use the above two types of models for updating the base AI model. Alternatively, the server (100) may not immediately decide not to use the above two types of models for updating the base AI model, but may determine whether the models are unsuitable models. In one or more embodiments, the method for determining whether the models are unsuitable models is as described above.
[0071] For example, the server (100) may decide not to use a personalized AI model that has the same source as an unsuitable model for further training. That is, the server (100) may exclude a personalized AI model generated by the same user terminal as the personalized AI model determined to be an unsuitable model from further training.
[0072] To this end, the server (100) can identify the source of the personalized AI model based on model-specific information. Since the model-specific information is generated based on the unique characteristics of the user terminal (1000), the server (100) can identify the user terminal (1000) that generated or transmitted the personalized AI model based on the model-specific information.
[0073] Alternatively, for example, the server (100) may calculate a score for the relevance between models (unsuitable models and personalized AI models) based on the location and time the model was created and the group to which the terminal that created the model belongs, and if the calculated score is above a preset threshold, it may decide not to use the personalized AI model for further training. To this end, the model-specific information may include information regarding the location and time the personalized AI model was created, the group of the terminal that created the model, etc.
[0074] The server (100) can transmit the basic AI model, updated through additional learning, to the user terminal (1000). Accordingly, the updated basic AI model can be stored back on the user terminal (1000) and executed in an on-device form.
[0075] 2. The overall process of the basic AI model running and updating
[0076] Below, the overall process of executing and updating the basic AI model will be described in detail with reference to FIGS. 2 to 7.
[0077] (1) Security execution framework of a user terminal (Fig. 2)
[0078] Before describing the overall process, a security execution framework of a user terminal (1000) for executing and fine-tuning a basic AI model is described. That is, how the environment in which the basic AI model is executed and fine-tuned is configured in one or more embodiments is described.
[0079] FIG. 2 illustrates a security execution framework included in a user terminal according to one embodiment of the present disclosure. Referring to FIG. 2, the user terminal (1000) may include a secure hardware-based Root-of-Trust (RoT) (1010), security firmware (1020), Regular Execution Environment (REE) (1030), and Trusted Execution Environment (TEE) (1040).
[0080] The security hardware-based RoT (1010) may correspond to a security module that is embedded in the CPU chip (1011) and configured to be immutable. The security hardware-based RoT (1010) maintains the security of the user terminal (1000) and, in particular, can guarantee the reliability or verify the integrity of the TEE (1040). That is, the security hardware-based RoT (1010) can ensure that the TEE (1040) is in a trustworthy environment. The CPU chip (1011) may be a configuration corresponding to or included in the processor (1300) of the user terminal (1000) illustrated in FIG. 8, which will be described later.
[0081] A security hardware-based Root of Trust (1010) can provide hardware-based security for key management and cryptographic operations. For example, the security hardware-based Root of Trust (1010) can generate a CPU ID based on the unique physical characteristics of a CPU chip (1011). The CPU ID may be used as a terminal key itself, or a terminal key may be generated based on the CPU ID. Additionally, the security hardware-based Root of Trust (1010) can generate model-specific information based on the terminal key.
[0082] The security firmware (1020) can establish a trusted environment in conjunction with the security hardware-based Root of Trust (1010) during the booting process of the user terminal (1000) and protect the system of the user terminal (1000) through firmware updates and security patches. The security firmware (1020) can perform signing on a personalized AI model using model-specific information.
[0083] There may be two separate execution environments, REE (1030) and TEE (1040), in the user terminal (1000). The two execution environments differ in security level and reliability.
[0084] REE (1030) is an environment for general applications and operating systems to run and can be implemented based on software. Since REE (1030) is protected only by software, it has low security and applications can run freely. Most programs, such as applications and browsers installed on a user terminal (1000), can run in REE.
[0085] In the REE (1030), client apps / services (1031) and host kernels / runtimes (1032) can be executed.
[0086] The client app / service (1031) may correspond to a general application for providing services to the user (1). According to one embodiment of the present disclosure, the user (1) can use the AI service through the client app / service (1031). That is, the client app / service (1031) can provide the AI service by providing the user (1) with a UI for using the AI service and by interacting with a basic AI model.
[0087] A client app / service (1031) can receive input data (e.g., prompt) for using the AI service from a user (1) through a UI. Input data collected during the process of the user (1) using the AI service can be used for fine-tuning the basic AI model. However, to protect the privacy of the user (1), the collected input data is not used directly as training data, but can be utilized as training data after being partially changed or modified. For example, the user terminal (1000) can process the collected input data by anonymizing it or by removing or converting sensitive information so that the user's (1) personal information is not included as is. Alternatively, for example, the user terminal (1000) can apply data transformation techniques (e.g., synonym substitution, sentence structure reorganization, etc.) to generate training data that is differentiated from the direct user input while maintaining the original meaning.
[0088] The client app / service (1031) can send requests for functions or actions that require security to the TEE (1040).
[0089] The host kernel / runtime (1032) corresponds to the operating system kernel and can provide a runtime environment for executing applications. That is, the host kernel / runtime (1032) can manage the execution of general applications and system resources.
[0090] The TEE (1040) is an execution environment for performing security-sensitive tasks and can be implemented on a hardware basis. For example, the TEE (1040) can be implemented by a protected area within a separate, security-enhanced processor or CPU chip (1011). That is, code executed in the TEE (1040) can be executed in a protected area within a separate, security-enhanced processor or CPU chip (1011).
[0091] The TEE (1040) ensures a higher level of security than the REE (1030) and can be protected from external attacks. The TEE (1040) is completely separated from the REE (1030), and malicious code running in the REE (1030) cannot access the TEE (1040). Therefore, data processed in the TEE (1040) is hardware-protected, and security-sensitive operations can be executed in the TEE (1040). For example, fine-tuning of a basic AI model using training data can be performed in the TEE (1040). Also, for example, operations requiring security among the operations performed by the AI engine can be executed in the TEE (1040).
[0092] In the TEE (1040), a trusted app / service (1041) and a secure kernel / runtime (1042) can be executed.
[0093] A trusted app / service (1041) is a security application running within the TEE (1040) and can perform security-related operations requested by the REE (1030). For example, when a client app / service (1031) requests a security operation from the trusted app / service (1041), the trusted app / service (1041) can return only the result to the REE (1030) after security verification.
[0094] According to one embodiment of the present disclosure, a trusted app / service (1041) can perform sensitive data processing of an AI model. For example, in the trusted app / service (1041), an AI engine can obtain a personalized AI model by performing fine-tuning on a basic AI model using training data.
[0095] The security kernel / runtime (1042) can manage the safe execution of trusted apps within the TEE (1040). That is, the security kernel / runtime (1042) can protect and execute trusted apps / services (1041). The security kernel / runtime (1042) ensures the secure execution of AI models and can protect them from external threats.
[0096] Figure 3 illustrates the operations performed by the user terminal and the server in sequence. Below, each operation will be described in detail according to the sequence shown in Figure 3.
[0097] (2) Provision of basic AI models
[0098] In step 301 of FIG. 3, the server (100) may transmit a basic AI model to a user terminal (1000). According to one embodiment of the present disclosure, the server (100) may request the user terminal (1000) to create a secure instance before transmitting the basic AI model.
[0099] When a user terminal (1000) requests the server (100) to download a base AI model, the server (100) may request the user terminal (1000) to create a hardware-based independent security instance within the TEE (1040). That is, the server (100) may request the creation of a new isolated execution environment within the TEE (1040) so that applications or functions requiring security can be executed. This is to provide an isolated execution environment for the base AI model to enhance security for the base AI model itself and for the fine-tuning of the base AI model.
[0100] When the user terminal (1000) creates a security instance in response to a request, the server (100) can transmit a basic AI model to the user terminal (1000).
[0101] (3) Run the basic AI model on the user terminal
[0102] The user terminal (1000) can execute the basic AI model received from the server (100) in an on-device environment.
[0103] In step 302 of FIG. 3, the user terminal (1000) can store the received basic AI model.
[0104] Next, in step 303 of FIG. 3, the user terminal (1000) can perform inference using a basic AI model according to user input. As previously described, the user terminal (1000) provides a UI for the user (1) to use the AI service through the REE (1030), and the user (1) can input a prompt (user input) through the UI.
[0105] The AI engine of the user terminal (1000) can execute a basic AI model in at least one of the REE (1030) and TEE (1040). For example, the AI engine can execute general operations using the basic AI model in the REE (1030) and only some operations requiring security in the TEE (1040). Or, for example, the AI engine can execute all operations of the basic AI model in either the REE (1030) or the TEE (1040).
[0106] (4) Creation of personalized AI models
[0107] In step 304 of FIG. 3, the user terminal (1000) can obtain a personalized AI model by fine-tuning a basic AI model based on user input used during inference. The AI engine of the user terminal (1000) can maintain the security of the personalized AI model by performing fine-tuning in the TEE (1040). According to one embodiment of the present disclosure, as fine-tuning for generating a personalized AI model is performed in an on-device environment, the model can be optimized while protecting the user's privacy.
[0108] In one or more embodiments, the user terminal (1000) can receive the following user input (input data) through the REE (1030).
[0109] - Text entered by the user (e.g., prompts, user-related information, etc.)
[0110] - Photos taken through a camera
[0111] - Voice information received through the microphone
[0112] - Various information that is directly input into the user terminal (1000) or collected by the user terminal (1000) during the process of the user using the AI service
[0113] The user terminal (1000) can obtain user data by collecting user input as described above and perform fine-tuning on a basic AI model using the user data.
[0114] If collected user data is used directly for fine-tuning, problems such as the leakage of personal information may occur. Therefore, according to one embodiment of the present disclosure, the user terminal (1000) can protect the privacy of the user (1) by not using the user data (input data) directly for fine-tuning, but by processing it into training data before using it for fine-tuning. For example, the user terminal (1000) can use the user data for additional learning after anonymizing and encrypting it.
[0115] In the user terminal (1000), a personalized AI model may be generated in the wrong direction. In this case, the term "wrong direction" can be interpreted in various ways; for example, a direction that is not desired by the service provider providing the basic AI model may be the wrong direction. Or, for example, a direction in which the model is trained to generate answers that deviate from general common sense may be the wrong direction. Or, for example, a direction in which the model is trained to generate answers that are excessively biased toward one side may be the wrong direction. (e.g., answers with excessively male-centric thinking, answers skewed toward either conservative or progressive views, etc.) In addition, if it becomes difficult for a large number of users to use it universally, it can be said that the personalized AI model was generated in the wrong direction.
[0116] Personalized AI models generated in the wrong direction are not suitable for use when updating the base AI model. In other words, personalized AI models generated in the wrong direction may be considered unsuitable models. For example, personalized AI models trained maliciously or with biased information may be classified as unsuitable models.
[0117] Attacks intended to maliciously contaminate the model may be attempted by utilizing the characteristics (anonymization) of the training data described above. For example, the user (1) may degrade the performance of the model or distort it in a specific direction by inputting malicious data while using the AI service. Alternatively, even if the user (1) has no malicious intent, biased information that causes the model to learn incorrectly may be used during fine-tuning.
[0118] (5) Transmission of model-specific information and personalized AI models (Figs. 4 and 5)
[0119] According to one embodiment of the present disclosure, a user terminal (1000) may transmit model-specific information and a personalized AI model when transmitting a personalized AI model to a server (100). The model-specific information may correspond to the personalized AI model. The user terminal (1000) may transmit the personalized AI model to the server after signing it using the model-specific information. The model-specific information may be used to determine whether the server (100) will reflect the personalized AI model in the update of the basic AI model.
[0120] In step 305 of FIG. 3, the user terminal (1000) can generate model-specific information based on the unique characteristics of the user terminal (1000). Hereinafter, with reference to FIG. 4 and FIG. 5, a method for the user terminal (1000) to generate model-specific information corresponding to a personalized AI model will be described in detail.
[0121] FIG. 4 illustrates a process in which a user terminal according to one embodiment of the present disclosure generates model-specific information, performs a signature on a personalized AI model using the generated model-specific information, and then transmits it to a server. Digital authentication-related operations described below (e.g., generating a terminal key, performing a signature, etc.) can be performed in the TEE (1040).
[0122] The user terminal (1000) can generate a device key (412) corresponding to the user terminal (1000). Since the device key (412) is generated based on the unique characteristics of the user terminal (1000), it can be used as identification information to distinguish the user terminal (1000) from other devices. Accordingly, the device key (412) can be used to verify the source of the personalized AI model.
[0123] According to one embodiment of the present disclosure, a user terminal (1000) can generate a terminal key (412) based on the unique physical characteristics of a CPU chip (1011). Referring to FIG. 4, the user terminal (1000) can generate a PUF-based key (CPU ID (411)) corresponding to the unique physical characteristics of the CPU chip (1011) through a PUF (Physical Unclonable Function). That is, the user terminal (1000) can generate a CPU ID (411) by utilizing minute physical variability occurring during the manufacturing process of the CPU chip (1011).
[0124] The user terminal (1000) may use the generated CPU ID (411) as is as the terminal key (412), or may generate the terminal key (412) using the CPU ID (411). For example, the user terminal (1000) may generate the terminal key (412) by adding various information corresponding to the user terminal (1000) (e.g., model name, serial number, etc.) to the CPU ID (411).
[0125] According to one embodiment of the present disclosure, the user terminal (1000) may generate a terminal key (412) using information other than the CPU ID (411). For example, the user terminal (1000) may generate a terminal key (412) using hardware-based unique information of the user terminal (1000), such as IMEI (International Mobile Equipment), MAC address, serial number, etc.
[0126] A user terminal (1000) can generate model-specific information (410) based on a terminal key (412). Model-specific information (410) according to one embodiment of the present disclosure may be a nonce generated to specify an event such as the creation or transmission of a personalized AI model. Accordingly, model-specific information (410) may be referred to as an event-specific nonce.
[0127] FIG. 5 illustrates details included in model specific information according to one embodiment of the present disclosure. Referring to FIG. 5, the model specific information may include the following details.
[0128] ① region: Information about the region where the user terminal (1000) is located (may indicate the region where the personalized AI model was generated)
[0129] ② locale: Information about the region settings (e.g., country, language settings) of the user terminal (1000).
[0130] ③ group: Information about the group to which the user terminal (1000) belongs (the group may be determined based on the user's (1) gender, age, etc.)
[0131] ④ device: Information about the user terminal (1000) (e.g., model name, serial number, etc.)
[0132] ⑤ date: Information about the date the personalized AI model was created
[0133] ⑥ Time: Information about the time the personalized AI model was created
[0134] ⑦ CPU ID: A PUF-based key corresponding to the CPU chip (1011) included in the user terminal (1000) (assuming the CPU ID is used as the terminal key)
[0135] ⑧ TEE ID: Information for identifying the TEE (1040) of the user terminal (1000) (Information for identifying the TEE (1040) for which a personalized AI model has been generated)
[0136] ⑨ instance ID: Information for identifying a security instance created in the TEE (1040) of the user terminal (1000) (information for identifying a security instance created by a personalized AI model)
[0137] As such, model-specific information may include information about the location and time where the personalized AI model was created, information based on the hardware properties of the user terminal that created the personalized AI model (CPU ID), and information based on the software environment where the personalized AI model was created (TEE ID, instance ID).
[0138] According to one embodiment of the present disclosure, a user terminal (1000) can generate model-specific information (410) by collecting detailed information, changing the array, and then performing hashing. The process of the user terminal (1000) generating model-specific information (410) will be explained in detail with reference to FIG. 5.
[0139] The first state (510) illustrated in FIG. 5 may represent a state in which the user terminal (1000) first collects detailed information. The first state (510) is divided into a static information area and a dynamic information area, wherein the static information area includes region, locale, group, device, and CPU ID, and the dynamic information area may include data, time, TEE ID, and instance ID.
[0140] The user terminal (1000) can change from a first state (510) to a second state (520) by rearranging the details. The second state (520) is divided into a public information area and a private information area. The public information area includes region, locale, group, device, date, and time, and the private information area may include CPU ID, TEE ID, and instance ID. The private information area may include a unique key (CPU ID) corresponding to the user terminal (1000), and may also include information (TEE ID, instance ID) about the environment in which the personalized AI model is generated on the user terminal (1000). That is, the details (CPU ID, TEE ID, instance ID) included in the private information area can be used as information to identify the source of the personalized AI model.
[0141] The user terminal (1000) can change from the second state (520) to the third state (530) by performing hashing on the details (CPU ID, TEE ID, instance ID) included in the personal information area. The user terminal (1000) can perform hashing on the details included in the personal information area using a randomly generated nonce.
[0142] According to one embodiment of the present disclosure, the user terminal (1000) performs hashing on individual fields for detailed information (CPU ID, TEE ID, instance ID) included in the personal information area, so that model-specific information can be used as information to identify the source of the personalized AI model.
[0143] In step 306 of FIG. 3, the user terminal (1000) can perform a signature on the personalized AI model using model-specific information. Referring to FIG. 4, the user terminal (1000) can obtain a terminal key (412) from the model-specific information (410) and perform a signature using the obtained terminal key (412).
[0144] The statement that a signature is performed on a personalized AI model (420) may actually mean that a signature is performed on the 'data of the personalized AI model'. In this case, the 'data of the personalized AI model' may include information about the structure of the nodes included in the personalized AI model and information about the parameters corresponding to each node.
[0145] The signature information can be transmitted to a server (100) and used to verify the integrity of the personalized AI model.
[0146] Next, in step 307 of FIG. 3, the user terminal (1000) can transmit model-specific information and a signed personalized AI model to the server (100). At this time, the user terminal (1000) may also transmit a certificate including a terminal key (412) to the server (100).
[0147] (6) Update of the basic AI model using the personalized AI model
[0148] The server (100) receives personalized AI models from multiple terminals, including a user terminal (1000), as needed or periodically, and can update a basic AI model using the received personalized AI models. The server (100) can exclude some of the received personalized AI models that are not suitable for further training and can further train the basic AI model with the remaining models.
[0149] In step 308 of FIG. 3, the server (100) can determine whether to use the personalized AI model for further training based on the received model-specific information. However, for this to happen, at least one of the previously received personalized AI models must have been determined to be an unsuitable model. Below, a method for determining whether a personalized AI model is an unsuitable model is first described, followed by a method for determining whether to use the personalized AI model for further training based on the model-specific information.
[0150] (6-1) Method for determining whether a personalized AI model is an unsuitable model (Figs. 6 and 7)
[0151] According to one embodiment of the present disclosure, the server (100) can detect an unsuitable model based on how much difference there is between the received personalized AI model and the basic AI model stored in the server (100).
[0152] In addition, according to one embodiment of the present disclosure, the server (100) can detect an unsuitable model based on how much difference there is between the model after the update of the basic AI model stored in the server (100) and the basic AI model (model before the update) using the received personalized AI model.
[0153] That is, the server (100) can determine whether the personalized AI model is an unsuitable model by comparing the parameters of the models. As previously explained, the server (100) can determine whether the personalized AI model is an unsuitable model based on the result of comparing the parameters of any one pair of the following models.
[0154] i) Compare parameters between the personalized AI model and the basic AI model
[0155] ii) Using a personalized AI model, compare parameters between the model after the base AI model is updated (post-update model) and the base AI model (pre-update model).
[0156] FIG. 6 is a diagram illustrating a method for determining whether a personalized AI model is an unsuitable model by comparing the parameters of a personalized AI model and a basic AI model. A server (100) can determine whether a personalized AI model (610) is an unsuitable model by comparing the parameters between a personalized AI model (610) and a basic AI model (620).
[0157] For example, the server (100) can calculate the difference in parameter values for each pair of corresponding nodes of the two models (610, 620), calculate the average of the differences calculated for all nodes, and compare the average with a predetermined threshold. If the average is greater than the predetermined threshold, the server (100) can determine that the personalized AI model (610) is an unsuitable model. At this time, a pair of corresponding nodes may refer to a pair of nodes that have the same location in each model.
[0158] In the embodiment illustrated in FIG. 6, the difference in parameter values calculated for each pair of corresponding nodes is 0.04, 0.48, 0.09, 0.51, 0.02, 0.01, and 0.13, and the average of these is 0.18. Therefore, if 0.18 is greater than a predetermined threshold, the server (100) can determine that the personalized AI model (610) is an unsuitable model.
[0159] Alternatively, for example, the server (100) may calculate the difference in parameter values for each corresponding pair of nodes of the two models (610, 620), calculate the variance of the difference calculated for all nodes, and compare the variance with a predetermined threshold. If the variance is greater than the predetermined threshold, the server (100) may determine that the personalized AI model (610) is an unsuitable model.
[0160] In the embodiment illustrated in FIG. 6, the difference in parameter values calculated for each pair of corresponding nodes is 0.04, 0.48, 0.09, 0.51, 0.02, 0.01, and 0.13, and their variance is 0.04. Therefore, if 0.04 is greater than a predetermined threshold, the server (100) can determine that the personalized AI model (610) is an unsuitable model.
[0161] Alternatively, for example, the server (100) may calculate the difference in parameter values for each corresponding pair of nodes of two models (610, 620), check the number of pairs of nodes that have a difference greater than a predetermined value, and if the number of confirmed pairs of nodes is greater than a predetermined threshold, the server (100) may determine that the personalized AI model (610) is an unsuitable model.
[0162] It is assumed that a criterion is set to determine that the personalized AI model (610) is an unsuitable model if there are two or more pairs of nodes where the difference in parameter values exceeds 0.4. Referring to FIG. 6, when comparing the first node (611) of the personalized AI model (610) with the second node (621) of the basic AI model (620), the difference in parameter values is 0.48. Also, when comparing the second node (612) of the personalized AI model (610) with the second node (622) of the basic AI model (620), the difference in parameter values is 0.51. Since there are two pairs of nodes where the difference in parameter values exceeds 0.4, the server (100) can determine that the personalized AI model (610) is an unsuitable model.
[0163] Figure 7 is a diagram illustrating a method for determining whether a personalized AI model is an unsuitable model by comparing parameters between a model after the basic AI model has been updated (model after update) and a basic AI model (model before update) using a personalized AI model.
[0164] Referring to FIG. 7, the server (100) can obtain an updated basic AI model (730) by performing additional training on the basic AI model (720) using the personalized AI model (710). Subsequently, the server (100) can determine whether the personalized AI model (710) corresponds to an unsuitable model by comparing parameters between the basic AI model (720) and the updated basic AI model (730).
[0165] For example, the server (100) can calculate the difference in parameter values for each corresponding pair of nodes of two models (720, 730), calculate the average of the differences calculated for all nodes, and compare the average with a predetermined threshold. If the average is greater than the predetermined threshold, the server (100) can determine that the personalized AI model (710) is an unsuitable model. At this time, a corresponding pair of nodes may refer to a pair of nodes that have the same location in each model.
[0166] In the embodiment illustrated in FIG. 7, the difference in parameter values calculated for each pair of corresponding nodes is 0.34, 0.06, 0.06, 0.16, 0.03, 0.09, and 0.44, and the average of these is 0.17. Therefore, if 0.17 is greater than a predetermined threshold, the server (100) can determine that the personalized AI model (710) is an unsuitable model.
[0167] Alternatively, for example, the server (100) may calculate the difference in parameter values for each corresponding pair of nodes of the two models (720, 730), calculate the variance of the difference calculated for all nodes, and compare the variance with a predetermined threshold. If the variance is greater than the predetermined threshold, the server (100) may determine that the personalized AI model (710) is an unsuitable model.
[0168] In the embodiment illustrated in FIG. 7, the difference in parameter values calculated for each pair of corresponding nodes is 0.34, 0.06, 0.06, 0.16, 0.03, 0.09, and 0.44, and their variance is 0.02. Therefore, the server (100) can determine that the personalized AI model (710) is an unsuitable model if 0.02 is greater than a predetermined threshold.
[0169] Alternatively, for example, the server (100) may calculate the difference in parameter values for each corresponding pair of nodes of two models (720, 730), check the number of pairs of nodes that have a difference greater than a predetermined value, and if the number of confirmed pairs of nodes is greater than a predetermined threshold, the server (100) may determine that the personalized AI model (710) is an unsuitable model.
[0170] It is assumed that a criterion is set to determine that the personalized AI model (710) is an unsuitable model if there are two or more pairs of nodes where the difference in parameter values exceeds 0.4. Referring to FIG. 7, when comparing the first node (721) of the basic AI model (720) with the first node (731) of the updated basic AI model (730), the difference in parameter values is 0.34. Also, when comparing the second node (722) of the basic AI model (720) with the second node (732) of the updated basic AI model (730), the difference in parameter values is 0.44. Since there is one pair of nodes where the difference in parameter values exceeds 0.4, the server (100) can determine that the personalized AI model (710) is not an unsuitable model.
[0171] (6-2) Method for determining whether to use a personalized AI model for further training based on model-specific information (Figs. 8 and 9)
[0172] If the server (100) discovers at least one personalized AI model corresponding to an unsuitable model according to the method described above, it can determine whether to use the subsequently received personalized AI models for updating the basic AI model based on the model-specific information received together.
[0173] According to one embodiment of the present disclosure, the server (100) may determine, based on model-specific information, whether a received personalized AI model corresponds to one of the following two types, and may decide not to use the models of the following two types for updating the base AI model. Alternatively, the server (100) may not immediately decide not to use the models of the following two types for updating the base AI model, but may determine whether the models correspond to unsuitable models. The method for determining whether the models correspond to unsuitable models is as described above.
[0174] i) Personalized AI model transmitted from a terminal that previously transmitted an unsuitable model
[0175] ii) Personalized AI models transmitted from terminals highly relevant to the terminal that previously transmitted an unsuitable model
[0176] Figures 8 and 9 are diagrams illustrating the process of determining whether a server will use a personalized AI model to update a basic AI model based on model-specific information.
[0177] Referring to FIG. 8, when a user terminal (1000) transmits a first personalized AI model and first model specific information to a server (100), the server (100) can determine whether the first personalized AI model corresponds to an unsuitable model.
[0178] The server (100) can determine whether the first personalized AI model corresponds to an unsuitable model based on the result of comparing parameters between the first personalized AI model and the basic AI model stored in the server (100) according to the method described above with reference to FIGS. 6 and 7. Alternatively, the server (100) can determine whether the first personalized AI model corresponds to an unsuitable model based on the result of comparing parameters between the model after the basic AI model is updated (model after update) and the basic AI model (model before update) using the first personalized AI model.
[0179] In the situation illustrated in FIG. 8, the server (100) assumes that the first personalized AI model is an unsuitable model.
[0180] After the first personalized AI model is determined to be an unsuitable model, if the user terminal (1000) transmits the second personalized AI model and second model specific information to the server (100), the server (100) can determine whether to use the second personalized AI model for updating the basic AI model based on the second model specific information. The specific process is as follows.
[0181] The server (100) can compare the source of the first personalized AI model and the second personalized AI model by comparing the first model-specific information and the second model-specific information. The personal information area of the model-specific information may include detailed information such as terminal key (e.g., CPU ID), TEE ID, and instance ID, and the server (100) can verify and compare the source of each model based on this detailed information. For example, if the terminal key included in the first model-specific information is the same as the terminal key included in the second model-specific information, the server (100) can determine that the source of the first personalized AI model and the second personalized AI model is the same. The server (100) may also refer to the TEE ID and instance ID when verifying and comparing the source.
[0182] In the embodiment illustrated in FIG. 8, the server (100) can confirm that the first personalized AI model and the second personalized AI model have been received from the same user terminal (1000), and therefore can decide not to use the second personalized AI model for updating the basic AI model. Alternatively, the server (100) can determine whether the second personalized AI model is an unsuitable model, and if it is an unsuitable model, decide not to use it for updating the basic AI model.
[0183] In this way, the server (100) can identify the source of the personalized AI model based on model-specific information and decide not to use the personalized AI model that has the same source as the unsuitable model for updating the basic AI model.
[0184] Referring to FIG. 9, when the first user terminal (1000) transmits the first personalized AI model and the first model specific information to the server (100), the server (100) can determine whether the first personalized AI model corresponds to an unsuitable model. The server (100) can determine whether the first personalized AI model corresponds to an unsuitable model according to the method described above.
[0185] In the situation illustrated in FIG. 9, the server (100) assumes that the first personalized AI model is an unsuitable model.
[0186] After the first personalized AI model is determined to be an unsuitable model, if the second user terminal (2000) transmits the second personalized AI model and second model specific information to the server (100), the server (100) can determine whether to use the second personalized AI model for updating the basic AI model based on the second model specific information. The specific process is as follows.
[0187] By comparing the first model-specific information and the second model-specific information, the server (100) can determine the relationship between the first user terminal (1000) that transmitted the unsuitable model (first personalized AI model) and the second user terminal (2000) that transmitted the second personalized AI model. That is, based on the model-specific information, the server (100) can determine what kind of relationship the two terminals (1000, 2000) have with each other, and to what extent the two terminals (1000, 2000) have a relationship with each other.
[0188] Model-specific information may include details such as the region and time in which the personalized AI model was created, and the group to which the terminal that transmitted the personalized AI model belongs, and the server (100) can determine the relationship between the first user terminal (1000) and the second user terminal (2000) based on these details.
[0189] If the relationship between the first user terminal (1000) and the second user terminal (2000) is any of the following, the server (100) may decide not to use the second personalized AI model for updating the basic AI model. Alternatively, if the relationship between the first user terminal (1000) and the second user terminal (2000) is any of the following, the server (100) may determine whether the second personalized AI model corresponds to an unsuitable model.
[0190] i) When the first user terminal (1000) and the second user terminal (2000) are owned by the same user
[0191] ii) When the first user terminal (1000) and the second user terminal (2000) are included in the same group
[0192] According to one embodiment of the present disclosure, the server (100) may determine the degree of correlation between an unsuitable model (a first personalized AI model) and a second personalized AI model based on model-specific information, and determine whether to use the second personalized AI model for updating the basic AI model based on the result.
[0193] For example, the server (100) may calculate a score for the relevance between an unsuitable model (a first personalized AI model) and a second personalized AI model based on the location and time each model was created and the group to which the terminal that created the model belongs, and if the calculated score is above a preset threshold, it may decide not to use the second personalized AI model for updating the basic AI model.
[0194] In this way, the server (100) can determine the relationship between the terminals that transmitted the two models based on model-specific information and decide not to use the personalized AI model transmitted from the terminal that is highly related to the terminal that previously transmitted the unsuitable model for additional learning.
[0195] If the server (100) has selected a personalized AI model to use for additional learning, it can update the basic AI model using the personalized AI model in step 309 of FIG. 3.
[0196] Next, in step 310 of FIG. 3, the server (100) can transmit the updated basic AI model to the user terminal (1000).
[0197] 3. Overall configuration and operation of the electronic device (user terminal) (Fig. 10)
[0198] Below, the configuration of a user terminal (1000) for performing the operations described so far is described.
[0199] FIG. 10 is a drawing illustrating the components included in a user terminal according to one embodiment of the present disclosure. Referring to FIG. 10, a user terminal (1000) according to one embodiment of the present disclosure may include a communication interface (1100), an input / output interface (1200), a processor (1300), and a memory (1400).
[0200] The communication interface (1100) is configured to transmit and receive signals (control commands and data, etc.) to and from an external device via wired or wireless means, and may be implemented to include a communication chipset that supports various communication protocols. The communication interface (1100) may receive signals from the outside and output them to the processor (1300), or transmit signals output from the processor (1300) to the outside. The user terminal (1000) may receive a basic AI model from the server (100) through the communication interface (1100) and transmit model-specific information and a signed personalized AI model to the server (100).
[0201] The input / output interface (1200) may include an input interface (e.g., touch screen, keyboard, microphone, etc.) for receiving commands or information from a user, and an output interface (e.g., display panel, speaker, etc.) for displaying the result of an operation according to a user's command or the status of the user terminal (1000). According to one embodiment of the present disclosure, the user terminal (1000) may receive input (e.g., prompt) from a user through the input / output interface (1200), and when an operation is completed, may output the result of the operation (e.g., inference result) through the input / output interface (1200).
[0202] A processor (1300) is a configuration that controls a series of processes to enable a user terminal (1000) to operate according to the embodiments described in this disclosure, and may be composed of one or more processors. One or more processors included in the processor (1300) may be circuitry such as a System on Chip (SoC) or an Integrated Circuit (IC). One or more processors included in the processor (1300) may be a general-purpose processor such as a Central Processing Unit (CPU), a Micro Processor Unit (MPU), an Application Processor (AP), or a Digital Signal Processor (DSP); a graphics-dedicated processor such as a Graphic Processing Unit (GPU) or a Vision Processing Unit (VPU); an artificial intelligence-dedicated processor such as a Neural Processing Unit (NPU); or a communication-dedicated processor such as a Communication Processor (CP). If one or more processors included in the processor (1300) are artificial intelligence-dedicated processors, said artificial intelligence-dedicated processors may be designed with a hardware structure specialized for processing a specific artificial intelligence model.
[0203] According to one embodiment of the present disclosure, the processor (1300) of FIG. 10 corresponds to the CPU chip (1011) of FIG. 2, or may include the CPU chip (1011) of FIG. 2.
[0204] The processor (1300) can write data to memory (1400) or read data stored in memory (1400), and in particular, can process data according to a predefined operation rule or artificial intelligence model by executing a program or at least one instruction stored in memory (1400). Accordingly, the processor (1300) can perform the operations described in the embodiments of the present disclosure, and the operations described in the present disclosure as being performed by the user terminal (1000) or modules included in the user terminal (1000) can be seen as being performed by the processor (1300) unless otherwise specified.
[0205] Memory (1400) is configured to store various programs or data and may be composed of a storage medium or a combination of storage media such as ROM, RAM, hard disk, CD-ROM, and DVD. Memory (1400) may not exist separately but may be configured to be included in the processor (1300). Memory (1400) may be composed of volatile memory, non-volatile memory, or a combination of volatile and non-volatile memory. Memory (1400) may store a program or at least one instruction for performing operations according to the embodiments described below. Memory (1400) may provide stored data to the processor (1300) upon the request of the processor (1300).
[0206] The embodiments described above with reference to FIGS. 1 to 9 can be performed by a user terminal (1000).
[0207] 4. Describe the process with reference to the flowcharts (Figs. 11 to 14)
[0208] Hereinafter, a method for updating an AI model in a cloud environment according to embodiments of the present disclosure will be described with reference to the flowcharts of FIGS. 11 to 14. Since the steps included in the flowcharts of FIGS. 11 to 14 can be performed by the user terminal (1000) of FIG. 10, the contents described above with reference to FIGS. 1 to 10 may be omitted below and can be applied in the same way to FIGS. 11 to 14.
[0209] Referring to Fig. 11, in step 1101, the user terminal can obtain and store a basic AI model from the server.
[0210] In step 1102, the user terminal can obtain a personalized AI model by performing fine-tuning on the basic AI model based on user data collected during the process of running the basic AI model in an on-device environment. At this time, to protect the user's privacy, the user terminal may anonymize or encrypt the user data, process it into training data, and then use it for fine-tuning.
[0211] In step 1103, the user terminal may generate model-specific information corresponding to the personalized AI model based on the unique characteristics of the user terminal. The model-specific information generated in this way may include information about the region and time in which the personalized AI model was generated, information based on the hardware characteristics of the user terminal, and information based on the software environment in which the personalized AI model was generated. In this case, the information based on the software environment in which the personalized AI model was generated may include information for identifying the security environment in which the personalized AI model is executed on the user terminal. The model-specific information may be used to determine whether to reflect the personalized AI model in the update of the base AI model on the server.
[0212] The detailed steps included in step 1103 are illustrated in Fig. 13.
[0213] Referring to FIG. 13, in step 1301, the user terminal can generate a PUF-based key corresponding to the processor included in the user terminal. That is, the user terminal can generate a PUF-based key corresponding to the unique physical characteristics of the processor.
[0214] Next, in step 1302, the user terminal can generate model-specific information using a PUF-based key.
[0215] Returning to Fig. 11, in step 1104, the user terminal can perform a signature for the personalized AI model using model-specific information. The detailed steps included in step 1104 are illustrated in Fig. 14.
[0216] Referring to Fig. 14, in step 1401, the user terminal can obtain a PUF-based key from model-specific information.
[0217] Next, in step 1402, the user terminal can generate a signature value for the data of the personalized AI model using a PUF-based key. At this time, the 'data of the personalized AI model' may include information about the structure of the nodes included in the personalized AI model and information about the parameters corresponding to each node.
[0218] Returning to Fig. 11, in step 1105, the user terminal can transmit model-specific information and a signed personalized AI model to the server.
[0219] Figure 12 illustrates the actions performed by the server after receiving model-specific information and a personalized AI model.
[0220] Referring to FIG. 12, in step 1201, the server can identify the source of the personalized AI model based on model-specific information. That is, the server can identify the terminal that created or transmitted the personalized AI model based on model-specific information. According to one embodiment of the present disclosure, the model-specific information includes detailed information such as a terminal key (e.g., CPU ID), TEE ID, and instance ID corresponding to the user terminal that transmitted the personalized AI model, and the server can identify the source of the personalized AI model based on this detailed information.
[0221] In step 1202, the server can compare the source of the previously received unsuitable model with the source of the personalized AI model.
[0222] In step 1203, the server may determine whether to use the personalized AI model for updating the base AI model stored on the server based on the result of comparing the sources. According to one embodiment of the present disclosure, the server may determine not to use the personalized AI model for updating the base AI model if the source of the previously received unsuitable model is the same as the source of the personalized AI model. Alternatively, according to one embodiment of the present disclosure, the server may determine not to use the personalized AI model for updating the base AI model if the terminal that transmitted the previously received unsuitable model (first terminal) and the terminal that transmitted the personalized AI model (second terminal) are not the same, but the owner of the first terminal and the second terminal is the same, or if the first terminal and the second terminal belong to the same group.
[0223] Returning to Fig. 12, in step 1204, the server can perform an update of the basic AI model stored on the server. Once the update of the basic AI model is completed, the server can transmit it back to the user terminal.
[0224] A method according to one embodiment of the present disclosure may include the steps of: a user terminal acquiring and storing a base AI model from a server; acquiring a personalized AI model by performing fine-tuning on the base AI model based on user data collected during the process of executing the base AI model at the user terminal; generating model-specific information corresponding to the personalized AI model based on unique properties of the user terminal; performing signing on the personalized AI model using the model-specific information; and transmitting the model-specific information and the signed personalized AI model to the server.
[0225] According to one embodiment, the step of generating the model-specific information may include the step of generating a PUF (Physical Unclonable Function)-based key corresponding to a processor included in the user terminal and the step of generating the model-specific information based on the PUF-based key.
[0226] According to one embodiment, the step of performing the signature includes the step of obtaining the PUF-based key from the model-specific information and the step of generating a signature value for the data of the personalized AI model using the PUF-based key, and the data of the personalized AI model may include information about the structure of the nodes included in the personalized AI model and information about the parameters corresponding to each node.
[0227] According to one embodiment, the model-specific information may include information about the region and time in which the personalized AI model was generated, information based on the hardware properties of the user terminal, and information based on the software environment in which the personalized AI model was generated.
[0228] According to one embodiment, information based on the software environment in which the personalized AI model is generated may include information for identifying the security environment in which the personalized AI model is executed on the user terminal.
[0229] According to one embodiment, the model-specific information may be used to determine whether to reflect the personalized AI model in the update of the base AI model on the server.
[0230] According to one embodiment, the method may further include the steps of: the server identifying the source of the personalized AI model based on the model-specific information; comparing the source of the personalized AI model with a previously received unsuitable model based on the result of comparing the sources; determining whether to use the personalized AI model for updating a basic AI model stored in the server based on the result of comparing the sources; and the server performing an update of the basic AI model stored in the server.
[0231] According to one embodiment, the step of determining whether to use the personalized AI model for updating the basic AI model stored on the server may determine not to use the personalized AI model for updating the basic AI model if the source of the previously received unsuitable model is the user terminal.
[0232] According to one embodiment, the step of determining whether to use the personalized AI model for updating the basic AI model stored on the server may determine not to use the personalized AI model for updating the basic AI model if the source of the previously received unsuitable model is a second user terminal, and the owner of the user terminal and the second user terminal are the same, or if the user terminal and the second user terminal are included in the same group.
[0233] According to one embodiment, the user data may include at least one of user input received during the process of the basic AI model being executed at the user terminal, a record of interaction between the user and the user terminal, and information related to the user.
[0234] A user terminal according to one embodiment of the present disclosure includes a memory in which a program or at least one instruction is stored and at least one processor operably coupled to the memory, wherein the user terminal can obtain and store a base AI model from a server, obtain a personalized AI model by performing fine-tuning on the base AI model based on user data collected during the process of executing the base AI model, generate model-specific information corresponding to the personalized AI model based on the unique properties of the user terminal, perform signing on the personalized AI model using the model-specific information, and then transmit the model-specific information and the signed personalized AI model to the server.
[0235] According to one embodiment, in generating the model-specific information, the user terminal may generate a PUF (Physical Unclonable Function)-based key corresponding to the processor, and then generate the model-specific information based on the PUF-based key.
[0236] According to one embodiment, in performing the signature, the user terminal obtains the PUF-based key from the model-specific information and then generates a signature value for the data of the personalized AI model using the PUF-based key, and the data of the personalized AI model may include information about the structure of the nodes included in the personalized AI model and information about the parameters corresponding to each node.
[0237] According to one embodiment, the model-specific information may include information about the region and time in which the personalized AI model was generated, information based on the hardware properties of the user terminal, and information based on the software environment in which the personalized AI model was generated.
[0238] According to one embodiment, information based on the software environment in which the personalized AI model is generated may include information for identifying the security environment in which the personalized AI model is executed on the user terminal.
[0239] According to one embodiment, the model-specific information may be used to determine whether to reflect the personalized AI model in the update of the base AI model on the server.
[0240] A system for updating an AI model in a cloud environment according to one embodiment of the present disclosure includes a user terminal that provides a basic AI model, a server for updating the basic AI model, and a UI for using the basic AI model. The user terminal may acquire and store the basic AI model from the server, acquire a personalized AI model by performing fine-tuning on the basic AI model based on user data collected during the process of executing the basic AI model, generate model-specific information corresponding to the personalized AI model based on the unique properties of the user terminal, perform signing on the personalized AI model using the model-specific information, and then transmit the model-specific information and the signed personalized AI model to the server.
[0241] According to one embodiment, the server may identify the source of the personalized AI model based on the model-specific information, compare the source of the personalized AI model with a previously received unsuitable model, determine whether to use the personalized AI model for updating the basic AI model stored on the server based on the result of comparing the sources, and then perform an update of the basic AI model stored on the server.
[0242] According to one embodiment, when determining whether to use the personalized AI model for updating a basic AI model stored on the server, if the source of the previously received unsuitable model is the user terminal, the server may decide not to use the personalized AI model for updating the basic AI model.
[0243] Various embodiments of the present disclosure may be implemented or supported by one or more computer programs, and computer programs may be formed from computer-readable program code and stored on a computer-readable medium. In the present disclosure, “application” and “program” may represent one or more computer programs, software components, instruction sets, procedures, functions, objects, classes, instances, related data, or parts thereof suitable for implementation in computer-readable program code. “Computer-readable program code” may include various types of computer code, including source code, object code, and executable code. “Computer-readable medium” may include various types of media accessible by a computer, such as read-only memory (ROM), random access memory (RAM), hard disk drive (HDD), compact disc (CD), digital video disc (DVD), or various types of memory.
[0244] Additionally, a device-readable storage medium may be provided in the form of a non-transitory storage medium. Here, a 'non-transitory storage medium' is a tangible device and may exclude wired, wireless, optical, or other communication links that transmit transient electrical or other signals. Meanwhile, this 'non-transitory storage medium' does not distinguish between cases where data is stored semi-permanently and cases where it is stored temporarily. For example, a 'non-transitory storage medium' may include a buffer in which data is stored temporarily. A computer-readable medium may be any available medium accessible by a computer and may include both volatile and non-volatile media, as well as removable and non-removable media. A computer-readable medium includes media in which data can be stored permanently and media in which data can be stored and subsequently overwritten, such as rewritable optical discs or erasable memory devices.
[0245] According to one embodiment, the method according to the various embodiments disclosed herein may be provided by being included in a computer program product. The computer program product may be traded between a seller and a buyer as a product. The computer program product may be distributed in the form of a device-readable storage medium (e.g., compact disc read-only memory (CD-ROM)), or distributed online (e.g., download or upload) through an application store or directly between two user devices (e.g., smartphones). In the case of online distribution, at least a portion of the computer program product (e.g., a downloadable app) may be temporarily stored or temporarily created on a device-readable storage medium, such as the memory of a manufacturer's server, an application store's server, or a relay server.
[0246] The foregoing description of the present disclosure is for illustrative purposes only, and those skilled in the art will understand that modifications can be easily made to other specific forms without altering the technical spirit or essential features of the present disclosure. For example, suitable results may be achieved even if the described techniques are performed in a different order than described, and / or components such as systems, structures, devices, circuits, etc., described are combined or assembled in a form different from described, or replaced or substituted by other components or equivalents. Therefore, the embodiments described above should be understood as illustrative in all respects and not restrictive. For example, each component described as a single unit may be implemented in a distributed manner, and components described as distributed may likewise be implemented in a combined form.
[0247] The scope of the present disclosure is defined by the claims set forth below rather than by the detailed description above, and all modifications or variations derived from the meaning and scope of the claims and equivalent concepts thereof should be interpreted as being included within the scope of the present disclosure.
Claims
1. A step in which a user terminal obtains a base AI model from a server; A step of obtaining a personalized AI model by performing fine-tuning on the basic AI model based on user data collected during the process of the user terminal executing the basic AI model on the user terminal; The step of the user terminal generating model-specific information corresponding to the personalized AI model based on the unique properties of the user terminal; The step of the user terminal performing a signing for the personalized AI model using the model-specific information; and A method comprising the step of the user terminal transmitting the model-specific information and the signed personalized AI model to the server.
2. In Paragraph 1, The step of generating the above model-specific information is, The step of the user terminal generating a PUF (Physical Unclonable Function) based key corresponding to at least one processor included in the user terminal; and A method characterized by including the step of the user terminal generating model-specific information based on the PUF-based key.
3. In either Paragraph 1 or Paragraph 2, The step of performing the above signature is, The step of the user terminal obtaining the PUF-based key from the model-specific information; and The above user terminal includes the step of generating a signature value for the data of the personalized AI model using the above PUF-based key, and A method characterized in that the data of the personalization AI model includes information about the structure of the nodes included in the personalization AI model and information about the parameters corresponding to each node.
4. In any one of paragraphs 1 through 3, The above model-specific information is, A method characterized by including information about the region and time in which the personalized AI model was generated, information based on the hardware properties of the user terminal, and information based on the software environment in which the personalized AI model was generated.
5. In any one of paragraphs 1 through 4, Information based on the software environment in which the above-mentioned personalized AI model was generated is, A method characterized by including information for identifying a security environment in which the personalized AI model is executed on the user terminal.
6. In any one of paragraphs 1 through 5, The above model-specific information is, A method characterized by being used to determine whether to reflect the personalized AI model in the update of the basic AI model on the above server.
7. In any one of paragraphs 1 through 6, A step in which the server identifies the source of the personalized AI model based on the model-specific information; A step in which the server compares the source of the previously received unsuitable model with the source of the personalized AI model; A step of determining whether the server will use the personalized AI model to update the basic AI model stored in the server based on the result of comparing the source of the personalized AI model with the source of the previously received unsuitable model; and A method characterized by further including the step of the server performing an update of the basic AI model stored on the server, as determined to use the personalized AI model for updating the basic AI model.
8. In any one of paragraphs 1 through 7, The step of determining whether to use the above-mentioned personalized AI model for updating the basic AI model stored on the server is: A method characterized by determining not to use the personalized AI model for updating the basic AI model if the source of the previously received unsuitable model is the user terminal.
9. In any one of paragraphs 1 through 8, The step of determining whether to use the above-mentioned personalized AI model for updating the basic AI model stored on the server is: The source of the previously received non-conforming model is a second user terminal, and A method characterized by deciding not to use the personalized AI model for updating the basic AI model when the user terminal and the second user terminal are included in the same group, or when the owner of the user terminal also owns the second user terminal.
10. In any one of paragraphs 1 through 9, The above user data is, A method characterized by including at least one of user input received during the process of executing the basic AI model at the user terminal, a record of interaction between the user and the user terminal, and information related to the user.
11. A computer-readable, non-transient recording medium storing instructions that perform the method of any one of claims 1 through 10 when executed by at least one processor.
12. In a user terminal (1000), Memory for storing instructions (1400); and It includes at least one processor (1300) that is operably coupled to the memory (1400) and includes a processing circuit, and By having at least one processor (1300) execute the instructions either alone or in cooperation, the user terminal (1000) Obtain a base AI model from the server (100), and A personalized AI model is obtained by performing fine-tuning on the basic AI model based on user data collected during the process of executing the basic AI model, and Based on the unique properties of the user terminal (1000), model-specific information corresponding to the personalized AI model is generated, and After performing signing for the personalized AI model using the above model-specific information, A user terminal that transmits the above model-specific information and the above-signed personalized AI model to the server (100).
13. In Paragraph 12, The above user terminal (1000) generates the above model-specific information, After generating a PUF (Physical Unclonable Function) based key corresponding to the above processor (1300), A user terminal characterized by generating model-specific information based on the above-mentioned PUF-based key.
14. In either Paragraph 12 or Paragraph 13, In performing the signature, the above user terminal (1000) After obtaining the PUF-based key from the above model-specific information, A signature value for the data of the personalized AI model is generated using the above PUF-based key, and A user terminal characterized in that the data of the personalization AI model includes information about the structure of the nodes included in the personalization AI model and information about the parameters corresponding to each node.
15. In any one of paragraphs 12 through 14, The above model-specific information is, A user terminal characterized by including information about the region and time in which the personalized AI model was generated, information based on the hardware properties of the user terminal, and information based on the software environment in which the personalized AI model was generated.
