Personalized authentication method, and server for performing same

Abstract

The present invention provides a personalized authentication method, and a server for performing same. The personalized authentication method comprises the steps of: collecting user data for a user using a user terminal; extracting similar data related to the user data; generating at least one cluster for the similar data, and assigning a difficulty tag to the cluster; determining, on the basis of the user data, question difficulty of question and answer data to be provided to the user terminal; generating question and answer data including a question and a correct answer corresponding to the question difficulty; and providing a question included in the generated question and answer data to the user terminal.

Description

Personalized authentication method and server performing it

[0001] The present invention relates to a personalized authentication method and a server performing the same. Specifically, the present invention relates to a personalized authentication method that can provide a more secure financial services environment by generating personalized question-and-answer data based on user-related data and using it for user authentication.

[0002]

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

[0004] As financial institutions and electronic financial service providers provide financial products and services through computing devices, the number of non-face-to-face financial transactions conducted online, without direct contact with financial institution or electronic financial service provider employees, is increasing.

[0005] Non-face-to-face financial transactions involve customers requesting financial transactions through their personal devices, such as computers or smartphones, and checking the results of the transaction on their own devices. For security and safety reasons, this process requires user authentication of the entity requesting the transaction.

[0006] Typically, user authentication is performed using user-predefined authentication information. For example, authentication information may include passwords, patterns, certificate information, or biometric information such as fingerprints. However, with the advancement of non-face-to-face financial transaction technology, technologies for hacking and cloning authentication methods have also advanced, increasing the likelihood of authentication methods being exposed or hacked.

[0007] Therefore, there is a growing need for new user authentication methods with enhanced security to provide a safe financial services environment.

[0008]

[0009] The purpose of the present invention is to provide a financial service environment that enables users to perform non-face-to-face financial transactions more safely by generating question-and-answer data (i.e., Q&A data) based on the user's personal data (hereinafter, user data) and using the data for user authentication.

[0010] In addition, an object of the present invention is to provide a personalized authentication method capable of generating question-and-answer data of different difficulty levels and providing the same to a user terminal, depending on the security level of the service provided to the user terminal.

[0011] In addition, an object of the present invention is to provide a personalized authentication method capable of providing question-and-answer data of different difficulty levels based on the user's activity level for an application installed on a user terminal or the need for enhanced authentication of a service to be provided.

[0012] In addition, an object of the present invention is to provide a personalized authentication method capable of providing personalized question-and-answer data to a user terminal by determining the difficulty of a question (hereinafter, question difficulty) provided to a user based on data of a group similar to user data and generating incorrect answer data based on the determined question difficulty.

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

[0014]

[0015] According to one embodiment of the present invention for achieving the above technical task, a personalized authentication method includes the steps of collecting user data for a user using a user terminal, extracting similar data related to the user data, generating at least one cluster for the similar data and assigning a difficulty tag to the cluster, determining a question difficulty of question-answer data to be provided to the user terminal based on the user data, generating question-answer data including a question and a correct answer corresponding to the question difficulty, and providing a question included in the generated question-answer data to the user terminal.

[0016] In addition, the step of generating the question-and-answer data may include a step of classifying attributes in the user data, a step of selecting a correct answer (A) from the user data based on the classified attributes, a step of extracting a first sample question (Qr) from a list of questions stored in advance, a step of generating a second sample question (Qg) using a deep learning model, and a step of generating the question-and-answer data based on the first sample question (Qr), the second sample question (Qg), and the correct answer (A) using a deep learning model.

[0017] In addition, the step of generating the question-and-answer data may further include a step of determining the difficulty of generating the generated question-and-answer data, a step of using the generated question-and-answer data as is when the question difficulty and the generation difficulty are the same, and a step of updating incorrect answer choices included in the generated question-and-answer data when the question difficulty and the generation difficulty are different.

[0018] In addition, the step of updating the incorrect answer choices may include the step of deriving incorrect answer choices using similar data of the cluster to which the difficulty tag corresponding to the question difficulty is assigned, and the step of updating the question-and-answer data so that the derived incorrect answer choices are reflected.

[0019] In addition, the above properties are divided into binary-category, multi-category or meta-category, and the multi-category may include columns related to amount or product type, and the meta-category may include columns related to time, gender, age, region or payment method.

[0020] In addition, the user data may include personal information including information about the user's age, income, gender, occupation or location, and financial activity information including financial product subscription information, transfer information, existence of a bankbook, payment amount, product usage information or financial application usage information.

[0021] Additionally, the step of assigning a difficulty tag to the cluster may include determining a difficulty tag of the cluster by comparing a first distance between the user data and the cluster with a predetermined range reference value.

[0022] In addition, the step of assigning a difficulty tag to the cluster may include the step of assigning a first difficulty, which is the most difficult difficulty, to the difficulty tag of the cluster when the first distance is less than a first range criterion, the step of assigning a second difficulty, which is easier than the first difficulty, to the difficulty tag of the cluster when the first distance exceeds the first range criterion and is less than a second range criterion, and the step of assigning a third difficulty, which is easier than the second difficulty, to the difficulty tag of the cluster when the first distance exceeds the second range criterion.

[0023] Additionally, the step of determining the question difficulty of the above question-and-answer data may include a step of determining the question difficulty of the question-and-answer data based on the user's activity data or the need for enhanced authentication.

[0024] In addition, the step of determining the question difficulty of the question-and-answer data may include a step of randomly determining the question difficulty of the question-and-answer data when the activity data is less than a predetermined standard, and a step of determining the question difficulty of the question-and-answer data to a predetermined second difficulty when the activity data is greater than the predetermined standard.

[0025] In addition, the activity data may include the number of times an application operated by the server is used or the cumulative amount of data input from the user terminal through the application, and the reference value may be determined based on personal information including the user's gender, age, or region.

[0026] In addition, the step of determining the question difficulty of the above-mentioned question-and-answer data may include a step of determining the question difficulty of the above-mentioned question-and-answer data as the first difficulty, which is the most difficult difficulty, if there is a need for enhanced authentication in the service provided by the user terminal.

[0027] In addition, the step of providing the above question to the user terminal may include a step of providing the choices included in the above question in the form of text or by converting them into an image corresponding to the text.

[0028] Additionally, the above question-and-answer data may include multiple-choice question-and-answer data consisting of questions and correct answers including multiple choices, or subjective question-and-answer data consisting of questions and correct answers not including multiple choices.

[0029] Meanwhile, a personalized authentication method according to another embodiment of the present invention for achieving the above technical task includes a step of collecting user data about a user using a user terminal, a step of generating question-and-answer data including questions and correct answers related to the user data, and a step of providing a question included in the question-and-answer data to the user terminal, wherein the step of generating the question-and-answer data includes a step of classifying attributes in the user data, a step of selecting a correct answer (A) from the user data based on the classified attributes, a step of extracting a first sample question (Qr) from a list of questions stored in advance or generating a second sample question (Qg) using a deep learning model, and a step of generating the question-and-answer data based on at least one of the first sample question (Qr) and the second sample question (Qg) and the correct answer (A) using a deep learning model.

[0030] In addition, the step of generating the question-and-answer data may further include a step of determining a question difficulty of the question-and-answer data to be provided to the user terminal based on the user data, a step of determining a generation difficulty of the generated question-and-answer data, a step of using the generated question-and-answer data as is when the question difficulty and the generation difficulty are the same, and a step of updating incorrect answer choices included in the generated question-and-answer data when the question difficulty and the generation difficulty are different.

[0031] Meanwhile, a server according to an embodiment of the present invention for achieving the above technical task includes a processor, a memory for loading a computer program executed by the processor, and an interface for exchanging data generated during the execution of the computer program with a user terminal, wherein the computer program includes a step of collecting user data about a user using the user terminal, a step of extracting similar data related to the user data, a step of creating at least one cluster for the similar data and assigning a difficulty tag to the cluster, a step of determining a question difficulty of question-answer data to be provided to the user terminal based on the user data, a step of creating question-answer data including a question and a correct answer corresponding to the question difficulty, and a step of providing a question included in the created question-answer data to the user terminal.

[0032]

[0033] The personalized authentication method according to an embodiment of the present invention can provide a more secure non-face-to-face financial business environment to users by generating question-and-answer data based on user data and using it for user authentication.

[0034] In addition, the personalized authentication method according to the present invention can simultaneously satisfy both enhanced security and user convenience in responding by generating question-and-answer data of different question difficulty levels according to the security level of the service provided to the user terminal and providing the data to the user terminal.

[0035] In addition, the personalized authentication method according to the present invention can provide question-and-answer data suitable for the service currently being used by the user to the user terminal by generating question-and-answer data of different question difficulty levels based on the user's activity level for the application installed on the user terminal or the need for enhanced authentication of the service to be provided.

[0036] In addition, the personalized authentication method according to the present invention can provide question-and-answer data in a more discriminatory and diverse form to the user terminal than the conventional technique of using question-and-answer data pre-stored in a database by generating incorrect answer data according to the question difficulty determined based on data of a group similar to the user data.

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

[0038]

[0039] FIG. 1 is a conceptual diagram illustrating a system for performing a personalized authentication method according to some embodiments of the present invention.

[0040] FIG. 2 is a block diagram illustrating a server according to some embodiments of the present invention.

[0041] Figure 3 is a flowchart of a personalized authentication method according to one embodiment of the present invention.

[0042] FIG. 4 is a drawing for explaining a method of assigning a difficulty tag in step S300 of FIG. 3.

[0043] Figure 5 is a flowchart illustrating an example of step S500 of Figure 3.

[0044] FIG. 6 is an example of user data for explaining steps S510 and S520 of FIG. 5.

[0045] Figure 7 is a graph for explaining an example of selecting the correct answer in step S520 of Figure 5.

[0046] FIG. 8 is a flowchart illustrating an example of a method for updating question-and-answer data in step S570 of FIG. 5.

[0047] Figure 9 is a block diagram illustrating an example of generating question-and-answer data in Figure 5.

[0048] Fig. 10 is a block diagram illustrating an example of the Q generation module or QA generation module of Fig. 9.

[0049] FIG. 11 is a diagram illustrating an example of generating question-and-answer data according to a personalized authentication method according to one embodiment of the present invention.

[0050] Figure 12 is a flowchart of a personalized authentication method according to another embodiment of the present invention.

[0051] Figure 13 is a flowchart of a personalized authentication method according to another embodiment of the present invention.

[0052] FIG. 14 is a diagram for explaining an example of question-and-answer data provided to a user terminal in step S600 of FIG. 3 or FIG. 12.

[0053] FIG. 15 is a diagram for explaining another example of question-and-answer data provided to a user terminal in step S600 of FIG. 3 or FIG. 12.

[0054] FIG. 16 is a diagram illustrating a hardware implementation of a system that performs a personalized authentication method according to some embodiments of the present invention.

[0055]

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

[0057] The terms first, second, A, B, etc. used in this specification and claims may be used to describe various components, but the components should not be limited by these terms. These terms are used only for the purpose of distinguishing one component from another. For example, without departing from the scope of the present invention, the first component may be referred to as the second component, and similarly, the second component may also be referred to as the first component. The term "and / or" includes any combination of a plurality of related listed items or any item among a plurality of related listed items.

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

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

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

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

[0062] In this specification, "question-answer data" refers to data containing a question (or problem) and its correct answer. Here, a "question" may include either a multiple-choice question with multiple choices or a subjective question without multiple choices. That is, depending on the question type (i.e., multiple-choice or subjective), the question data may or may not include multiple choices.

[0063] Hereinafter, a personalized authentication method and a server performing the same according to some embodiments of the present invention will be described with reference to FIGS. 1 to 16.

[0064]

[0065] FIG. 1 is a conceptual diagram illustrating a system for performing a personalized authentication method according to some embodiments of the present invention.

[0066] Referring to FIG. 1, a system for performing a personalized authentication method according to some embodiments of the present invention includes a server (100) and a user terminal (200). Additionally, in some embodiments, the system may further include a separate database (400).

[0067] First, the user terminal (200) can be configured to provide the user with a financial service environment provided by the server (100).

[0068] Here, the user terminal (200) refers to a communication terminal capable of operating an application in a wired or wireless communication environment. In some embodiments, the user terminal (200) may be a user's portable terminal. That is, the user terminal (200) may be a smart phone, which is a type of portable terminal, but may be equipped with an application capable of providing a financial service environment of the server (100), and may be applied without limitation to a device capable of receiving user input and outputting financial services to the user.

[0069] For example, the user terminal (200) may include various types of electronic devices such as a personal computer (PC), a laptop, a tablet, a mobile phone, a smartphone, a wearable device (e.g., a watch-type terminal), etc.

[0070] A user can utilize the financial service environment provided by the server (100) using such a user terminal (200). At this time, the server (100) can operate and manage multiple user accounts, and the user may be an entity that wishes to utilize a financial service related to one of the multiple user accounts.

[0071] In this case, the user may be the owner of the user account, but may also be an intruder attempting to use the user account without authorization. Therefore, the server (100) may, if necessary, request user authentication from the user terminal (200) using the financial service. The server (100) performs user authentication through the user terminal (200), and if the user authentication is successfully performed, the server (100) may provide the user terminal (200) with financial services related to the specific user account.

[0072]

[0073] To this end, in some embodiments of the present invention, the server (100) may provide a user-related question to the user terminal (200) and perform user authentication based on the user's answer received through the user terminal (200).

[0074] At this time, the server (100) uses user data associated with a specific user account to generate personalized question-and-answer data (i.e., data consisting of questions and answers) that only the specific user can understand. Subsequently, the server (100) provides the questions included in the generated question-and-answer data to the user terminal (200), receives the answers from the user terminal (200), and determines whether the answers match the answers, thereby performing user authentication.

[0075] Here, the question-and-answer data may include multiple-choice question-and-answer data consisting of questions with multiple choices and correct answers, and subjective question-and-answer data consisting of questions without multiple choices and correct answers. That is, the server (100) may provide subjective or objective questions to the user terminal (200) and perform user authentication based on the answers thereto.

[0076] Additionally, the server (100) can determine the difficulty level of questions to be provided to the user terminal (200) based on the user data or the type of service currently being provided. That is, the server (100) can generate question-and-answer data of various question difficulties based on the user data, and can configure the similarity between correct and incorrect answers, or the type of questions included in the question-and-answer data differently based on the question difficulty level.

[0077] For example, if the determined question difficulty is relatively high, the similarity between incorrect and correct answers included in the question-and-answer data may increase, and if the question difficulty is relatively low, the similarity between incorrect and correct answers included in the question-and-answer data may decrease. Furthermore, if the determined question difficulty is relatively high, question-and-answer data including questions with a low correct answer rate may be selected, and if the question difficulty is relatively low, question-and-answer data including questions with a high correct answer rate may be selected. However, this is merely an example, and the present invention is not limited thereto.

[0078] Below, we will look in detail at a method for determining the question difficulty of question-and-answer data to be provided by a server (100) to a user terminal (200), a method for generating and updating question-and-answer data used for user authentication based on user data, and a method for providing the generated question-and-answer data to a user terminal (200).

[0079]

[0080] Meanwhile, the database (400) refers to a separate server that stores and manages user data of various users. That is, the server (100) can receive data stored in the separate database (400) and generate question-and-answer data. However, for convenience of explanation, the following description will be given as an example of generating question-and-answer data using user data stored in the database (120 in FIG. 2) included in the server (100).

[0081] Additionally, the communication network (300) plays a role of connecting the server (100) and the user terminal (200). That is, the communication network (300) refers to a communication network that provides a connection path so that the user terminal (200) can transmit and receive data after connecting to the server (100). The communication network (300) may include wired networks such as LANs (Local Area Networks), WANs (Wide Area Networks), MANs (Metropolitan Area Networks), and ISDNs (Integrated Service Digital Networks), or wireless networks such as wireless LANs, LTE, 5G, Bluetooth, and satellite communication, but the scope of the present invention is not limited thereto.

[0082] Additionally, the personalized authentication method according to some embodiments of the present invention may be implemented solely on the server (100), or may be implemented simultaneously on the server (100) and the user terminal (200). However, for convenience of explanation, the following description will be made using the server (100) as an example in which the personalized authentication method according to some embodiments of the present invention is performed. Hereinafter, with reference to FIG. 2, each component and module of the server (100) will be described.

[0083]

[0084] FIG. 2 is a block diagram illustrating a server according to some embodiments of the present invention.

[0085] Referring to FIG. 2, a server (100) according to some embodiments of the present invention includes an interface (110), a database (120), a processor (130), and a memory (140).

[0086] At this time, the processor (130) may drive (or execute) a preprocessing module (hereinafter, PM), a question generating module (hereinafter, QGM), and a question and answer generating module (hereinafter, QAGM). In addition, according to an embodiment, the processor (130) may additionally drive a question update module (hereinafter, QUM).

[0087] Each module may be stored and utilized in the form of a computer program in a database (120) or memory (140) included in the server (100). In some embodiments of the present invention, some of the modules described above may be omitted and implemented.

[0088] Specifically, the interface (110) can transmit data received by the server (100) from the user terminal (200) to other components within the server (100). The interface (110) can be provided in the server (100) and connected to an input / output device for receiving user input. In addition, the interface (110) can include various communication modules and can perform data exchange between the user terminal (200) or the database (400) via the communication network (300).

[0089] The database (120) performs the function of storing and managing data received through the interface (110). At this time, the database (120) may include a user information database (User-information DB; hereinafter, UDB) or a QA database (Question and Answer DB; hereinafter, QADB).

[0090] Here, the User Information Database (UDB) refers to a database that stores and manages user data for multiple users. The UDB can store and manage data (i.e., user data) related to multiple users, organized by user account.

[0091] A QA database (QADB) is a database that stores and manages question-and-answer data consisting of questions and their corresponding answers. A QADB can store and manage various examples of multiple question-and-answer data, and each question-and-answer data can include multiple-choice question-and-answer data consisting of questions with multiple-choice answers and correct answers, and subjective question-and-answer data consisting of questions without multiple-choice answers and correct answers. However, these are only a few examples of a single question-and-answer data, and the present invention is not limited thereto.

[0092] In another embodiment of the present invention, the user information database (UDB) and the QA database (QADB) may be included and utilized in a separate database (400) different from the server (100). However, for convenience of explanation, the following description will be given as an example of utilizing the user information database (UDB) and the QA database (QADB) included in the database (120).

[0093] Additionally, the database (120) may store and manage not only training data for training a deep learning model, but also weights of a neural network composed of multiple layers (i.e., neural network weights of a pre-trained deep learning model). However, this is merely an example, and the present invention is not limited thereto.

[0094] The processor (130) may execute software to control at least one other component (e.g., hardware or software component) of the server (100) and perform various data processing and operations. For example, the processor (130) may load information, commands, or data received from another component (e.g., database (120) or memory (140)) into its internal memory, perform operations using the loaded information, commands, or data, and store the resulting data in the database (120) or storage (not shown). At this time, the processor (130), as a subject performing the operations, may read necessary commands from the memory (140) and perform specific functions according to a predefined program.

[0095] The memory (140) can load and store various data used in at least one component (e.g., processor (130)) of the server (100). For example, the data may include input data or output data for software and commands related thereto. In other words, the memory (140) refers to a recording medium or storage device that stores software modules, command sets, etc. required for the operation of the system of the present invention.

[0096] Accordingly, the processor (130) can read and use modules or instructions related to various operations of a personalized question-and-answer data providing method according to some embodiments of the present invention from the memory (140).

[0097] Below, the operation of each module executed by the processor (130) is described.

[0098]

[0099] Specifically, the preprocessing module (PM) can perform an operation of classifying data (or first data) for predetermined attributes within user data, and selecting data (or second data) for the correct answer within the data included in a specific attribute among the classified attributes. In addition, the preprocessing module (PM) can generate third data to be input to the Q generation module (QGM) or QA generation module (QAGM) based on the first data for the attribute and the second data for the correct answer. A detailed description thereof will be provided below with reference to FIGS. 6, 7, and 9.

[0100] Next, the preprocessing module (PM) can use the generated third data to extract a first sample question having a high similarity to the third data from the QA database (QADB) included in the database (120). At this time, the processor (130) can extract a first sample question that includes a keyword included in the third data or is similar to the keyword from among the question and answer data (or question list) pre-stored in the QA database (QADB). However, this is only one example of extracting the first sample question, and the present invention is not limited thereto.

[0101] Meanwhile, the Q generation module (QGM) can generate a second sample question related to the third data by taking the third data generated by the preprocessing module (PM) as input. Here, the Q generation module (QGM) can include a deep learning model including a neural network. That is, the Q generation module (QGM) can receive data about attributes (i.e., first data) and data about correct answers (i.e., second data) as input, and output a second sample question generated based on the first and second data as output. A specific example of a deep learning model included in the Q generation module (QGM) will be described below with reference to FIG. 10.

[0102] Next, the QA generation module (QAGM) can generate question-and-answer data. At this time, the QA generation module (QAGM) can input data on the first sample question, the second sample question, and the correct answer (i.e., the second data) derived in the above-described step, and output question-and-answer data related thereto. At this time, the QA generation module (QAGM), like the Q generation module (QGM), can include a deep learning model including a neural network.

[0103] Next, the processor (130) can provide a question to the user terminal (200) based on the question-and-answer data generated by the QA generation module (QAGM), and perform user authentication based on the answer received from the user terminal (200).

[0104]

[0105] Additionally, the question update module (QUM) can determine the difficulty of generating question and answer data generated by the QA generation module (QAGM) and compare the determined difficulty of generating the question with the difficulty of providing the question to the user terminal (200).

[0106] At this time, if the generation difficulty is the same as the question difficulty, the question update module (QUM) can use the question and answer data generated by the QA generation module (QAGM) as is. On the other hand, if the generation difficulty is different from the question difficulty, the question update module (QUM) can update the answer choices included in the question and answer data generated by the QA generation module (QAGM). At this time, the question update module (QUM) can regenerate the incorrect answer choices for the question and answer data to correspond to the question difficulty and reflect the regenerated incorrect answer choices in the question and answer data.

[0107] That is, the question update module (QUM) can input the difficulty level (i.e., question difficulty level) of the question to be provided to the user terminal (200), generate incorrect answer choices that match the input question difficulty level, and reflect them in the question-and-answer data. Here, the difficulty level of the question to be provided to the user terminal (200) can be determined in various ways, and a detailed explanation thereof will be provided below.

[0108] Next, the processor (130) may provide a question to the user terminal (200) based on the question and answer data output from the question update module (QUM) and perform user authentication using the answer received from the user terminal (200). However, in some other embodiments of the present invention, the question update module (QUM) may be omitted.

[0109] Below, a personalized authentication method according to one embodiment of the present invention will be examined in detail.

[0110]

[0111] Figure 3 is a flowchart of a personalized authentication method according to one embodiment of the present invention. Figure 4 is a diagram illustrating a method for assigning a difficulty tag in step S300 of Figure 3. For convenience of explanation, the following description will be given as an example where the server (100) or processor (130) is used as the execution entity of the personalized authentication method.

[0112] First, referring to FIG. 3, in a personalized authentication method according to one embodiment of the present invention, a server (100) collects user data from a user terminal (200) (S100). Here, the user data may include the user's personal information (e.g., age, income, gender, occupation, location, etc.) or financial activity information (e.g., financial product subscription information, transfer information, account status, payment amount, product usage information, application usage information, etc.). However, this is merely an example of user data, and the present invention is not limited thereto.

[0113] Next, the server (100) extracts similar data related to the user data (S200). Here, similar data refers to data similar to personal information or financial activity information included in the user data of a user using the user terminal (200). The server (100) can extract user data similar to personal information or financial activity information included in the user data of a user using the user terminal (200) as similar data from among a plurality of user data previously stored in the database (120).

[0114] Next, the server (100) creates at least one cluster for similar data related to user data (S300).

[0115] At this time, the server (100) can create at least one cluster based on the similarity between the extracted plurality of similar data. Specifically, the server (100) can arrange the extracted plurality of similar data on a predetermined coordinate axis and create one or more clusters based on the distribution of each similar data.

[0116] For example, referring to FIG. 4, the circle-shaped dots each represent similar data, and based on the distribution of the similar data, the server (100) can create three clusters (CL1, CL2, CL3).

[0117] Next, the server (100) can assign a difficulty tag to the Q&A data based on the distance between the user data and the cluster (S300). At this time, the server (100) can determine the difficulty tag for each cluster by comparing the distance between the user data and the cluster with a predetermined range reference value. At this time, the distance between the user data and the cluster may refer to the distance between the user data and the center of the cluster, but the present invention is not limited thereto.

[0118] For example, referring to FIG. 4, the server (100) can determine a difficulty tag (D_tag1) of the first cluster (CL1) by comparing a first distance (d1) between the user data (UD) and the first cluster (CL1) with a predetermined range criterion. In the same manner, the server (100) can determine a difficulty tag (D_tag2) of the second cluster (CL2) by comparing a second distance (d2) between the user data (UD) and the second cluster (CL2) with a predetermined range criterion.

[0119] As a more specific example, when the first distance (d1) is less than the first range criterion (e.g., 0.2), the server (100) may assign the first difficulty (e.g., Hard difficulty), which is the hardest difficulty, to the difficulty tag (D_tag1) of the first cluster (CL1). On the other hand, when the first distance (d1) exceeds the first range criterion (e.g., 0.2) and is less than the second range criterion (e.g., 0.5), the server (100) may assign the second difficulty (e.g., Semi-hard difficulty), which is easier than the first difficulty, to the difficulty tag (D_tag1) of the first cluster (CL1). In addition, when the first distance (d1) exceeds the second range criterion (e.g., 0.5), the server (100) may assign the third difficulty (e.g., Easy difficulty), which is easier than the second difficulty, to the difficulty tag (D_tag1) of the first cluster (CL1). In the same manner, the server (100) can also assign difficulty tags to other second or third clusters. However, this is merely an example of assigning difficulty tags, and the present invention is not limited thereto.

[0120] If the difficulty tag of the first cluster (CL1) is assigned as the first difficulty level (e.g., Hard difficulty level), the server (100) can use the similar data included in the cluster (CL1) to generate question-and-answer data of the first difficulty level. Similarly, if the difficulty tag of the second cluster (CL2) is assigned as the second difficulty level (e.g., Semi-hard difficulty level), the server (100) can use the similar data included in the cluster (CL2) to generate question-and-answer data of the second difficulty level.

[0121] Meanwhile, the server (100) determines the question difficulty level to be provided to the user terminal (200) based on user data (S400). At this time, the server (100) may determine the question difficulty level of the Q&A data to be provided to the user terminal (200) based on the user's activity data using the user terminal (200) or the need for enhanced authentication.

[0122] Here, activity data includes the number of times an application running on the server (100) is used or the cumulative amount of data input from the user terminal (200) via the application. However, this is merely one example of activity data, and the present invention is not limited thereto. Furthermore, the need for enhanced authentication may be determined based on the security level of the service currently provided by the server (100) to the user terminal (200).

[0123] For example, if the activity data for a user using a user terminal (200) is less than a predetermined standard, the server (100) may randomly determine the question difficulty of the Q&A data. On the other hand, if the activity data for the user is greater than the predetermined standard, the server (100) may determine the question difficulty of the Q&A data to a second difficulty level (e.g., Semi-hard difficulty) that is a predetermined difficulty level.

[0124] Here, the reference value may be determined based on personal information, including the gender, age, or region of the user using the user terminal (200), and may be determined based on an average value of detailed attributes of personal information included in similar data similar to the user data. However, this is merely an example of a reference value, and the present invention is not limited thereto.

[0125] As another example, if a service provided by a user terminal (200) requires enhanced authentication, the server (100) may determine the question difficulty of the Q&A data to be the highest difficulty, i.e., "Hard" difficulty. Specifically, cases requiring enhanced authentication may include cases where the user terminal (200) provides services requiring high security, such as a money transfer service, a credit information inquiry service, or a financial inquiry service. However, these are only a few examples of cases requiring enhanced authentication, and the present invention is not limited thereto.

[0126] That is, the server (100) can determine the difficulty level of the questions to be provided to the user terminal (200) based on the user's activity data or the need for enhanced authentication. However, the above examples are merely a few examples of determining the question difficulty level of the Q&A data in the present invention, and the present invention is not limited thereto.

[0127] Next, the server (100) generates question-and-answer data corresponding to the determined question difficulty level (S500). At this time, the server (100) can generate the question-and-answer data using similar data included in the cluster that has the same difficulty tag as the determined question difficulty level. That is, the server (100) can derive specific attributes included in the similar data as common attributes and generate the question-and-answer data using the derived common attributes. A detailed description thereof will be provided below with reference to FIGS. 5 and 6.

[0128] Next, the server (100) provides the question included in the generated question-and-answer data to the user terminal (200) (S600).

[0129] Next, the server (100) can perform user authentication by receiving an answer to a question from the user terminal (200) and determining whether it matches the correct answer included in the question-and-answer data.

[0130]

[0131] Additionally, in another embodiment of the present invention, steps S200 and S300 described above may be omitted. That is, the server (100) may determine the question difficulty of the question-and-answer data to be provided to the user terminal (200) without considering similar data related to the user data. Furthermore, the server (100) may generate the question-and-answer data solely based on the user data, separate from similar data, and determine whether to update the incorrect answer choices for the question-and-answer data. Specific examples of this will be described below with reference to FIGS. 12 and 13.

[0132] Below, we will look at an example of generating a question (or question-and-answer data including the same) to be provided to a user terminal (200) in some embodiments of the present invention.

[0133]

[0134] FIG. 5 is a flowchart illustrating an example of step S500 of FIG. 3. FIG. 6 is an example of user data illustrating steps S510 and S520 of FIG. 5. FIG. 7 is a graph illustrating an example of selecting the correct answer in step S520 of FIG. Below, any content that overlaps with the above will be briefly explained, with a focus on the differences.

[0135] First, referring to FIG. 5, the server (100) classifies attributes of user data (S510). At this time, the server (100) uses table data containing the user data, and the table data may also include similar data of clusters assigned a difficulty tag identical to the question difficulty determined in step S400. However, this is merely an example, and the table data may of course only include user data. For convenience of explanation, the following description will be given as an example where the table data includes both user data and similar data corresponding to the question difficulty.

[0136] Specifically, Fig. 6 illustrates an example of table data. Table data may be composed of multiple columns. At this time, table data may be classified into binary categories, multi-categories (or numeric categories), or meta-categories depending on their attributes. Here, binary categories refer to columns with two or fewer options, and multi-categories refer to columns with more than two options. Meta-categories refer to columns that include predetermined items.

[0137] For example, in Fig. 6 <a1>Referring to FIG. 6, the binary category may include a column (c15) related to the inquiry type (online or offline), and the multi-category may include columns (c13, c14) related to the amount (Amount) or the type of product (Merchant). In addition, the meta-category may include columns (C12, C16, C18) related to the time (date), gender, age, region (Addr.), or payment method (Pay.). In this case, in FIG. 6, <a2>Refers to table data that has been converted to correspond to each attribute, such as user data and similar data corresponding to question difficulty. However, this is only an example of table data, and the present invention is not limited thereto.

[0138] Additionally, the server (100) can separately classify common attributes (M) that can be anonymized or pseudonymized in table data. For example, common attributes (M) may include columns corresponding to gender, age, consumption patterns, or meta-categories. However, this is merely an example, and the present invention is not limited thereto.

[0139] Next, the server (100) selects the correct answer (A) from the user data based on the attributes of the classified table data (S520). At this time, the correct answer (A) may be selected as any one of the values ​​included in the user data, and the server (100) may select one attribute from among the predefined attributes according to a predefined priority and select the value of the user data corresponding to the attribute as the correct answer (A).

[0140] For example, predefined attributes can be selected as attributes corresponding to multi-categories, and predefined priorities can be determined using the normal distribution disclosed in FIG. 7.

[0141] As a more specific example, the server (100) may select a value included in a randomly selected column among the attributes corresponding to a multi-category as the correct answer (A), or may select a value furthest from the average (population mean) in the normal distribution of each attribute of the table data as the correct answer (A). However, this is merely one example of selecting the correct answer (A), and the present invention is not limited thereto.

[0142] Next, the server (100) extracts a first sample question (Qr) from a pre-stored question list (S530). At this time, the first sample question (Qr) may be extracted based on the similarity with a keyword included in a pre-defined attribute or a selected correct answer (A) within a QA database (QADB) included in the database (120). For example, the server (100) may extract a first sample question (Qr) similar to a pre-defined attribute or a selected correct answer (A) using a keyword search method, a semantic search method, a latent space search method, etc. However, these are only a few examples of extracting the first sample question (Qr), and the present invention is not limited thereto.

[0143] Meanwhile, the server (100) generates a second sample question (Qg) using a Q generation module (QGM) including a deep learning model (S540). At this time, the Q generation module (QGM) may be pre-trained to output the second sample question (Qg) by inputting a predetermined attribute or a selected correct answer (A). An example of a deep learning module constituting the Q generation module (QGM) will be described below with reference to FIG. 10.

[0144] Next, the server (100) generates question-and-answer data using a QA generation module (QAGM) including a deep learning model based on the first sample question (Qr), the second sample question (Qg), and the correct answer (A) (S550). Similarly, an example of a deep learning module constituting the QA generation module (QAGM) will be described below with reference to FIG. 10.

[0145] Next, the server (100) determines the difficulty of generating the question-and-answer data generated by the QA generation module (QAGM) (S560). At this time, the difficulty of generating the question-and-answer data may be determined based on whether the generated question-and-answer data (or the question included in the question-and-answer data, or the choice included in the question) is closest to which of at least one of the aforementioned clusters.

[0146] For example, if the difficulty tag of the cluster closest to the question-and-answer data is a second difficulty level (e.g., Semi-hard difficulty), the difficulty level of the generated question-and-answer data may be determined to be the second difficulty level. However, this is merely an example, and the present invention is not limited thereto.

[0147] Next, the server (100) compares the difficulty of generating the question-and-answer data with the difficulty of the question to be provided to the user terminal (200) to determine whether to update the question-and-answer data (S570).

[0148] Below, we will examine a method for determining whether to update question-and-answer data in the present invention.

[0149]

[0150] FIG. 8 is a flowchart illustrating an example of a method for updating question-and-answer data in step S570 of FIG. 5.

[0151] Referring to FIG. 8, following step S560 of FIG. 5, the server (100) compares the generation difficulty of newly generated question-and-answer data (determined in step S560) with the question difficulty of question-and-answer data to be provided to the user terminal (200) (determined in step S400) (S571).

[0152] If the question difficulty and the generation difficulty are the same, the server (100) uses the generated question-and-answer data as is (S573). That is, the server (100) can provide the questions included in the question-and-answer data to the user terminal (200) without updating the question-and-answer data generated by the QA generation module (QAGM).

[0153] On the other hand, if the question difficulty and the generation difficulty are different, the server (100) updates the incorrect answer choices included in the question of the generated question-and-answer data to correspond to the question difficulty (S575). That is, the server (100) can extract incorrect answer choices included in the question-and-answer data using the question update module (QUM) and update the question-and-answer data so that the extracted incorrect answer choices satisfy the question difficulty determined in step S400. At this time, the question update module (QUM) can extract incorrect answer choices using a cluster assigned a difficulty tag identical to the question difficulty, but the present invention is not limited thereto.

[0154] Next, the server (100) can perform user authentication by providing a question to the user terminal (200) using the question-and-answer data confirmed through step S573 or step S575 and determining whether the answer received from the user terminal (200) matches the correct answer included in the question-and-answer data.

[0155] Through this, the personalized authentication method according to the present invention can provide question-and-answer data in a more discriminatory and diverse form to the user terminal than the conventional technique that uses question-and-answer data pre-stored in a database by generating incorrect answer data according to the question difficulty determined based on data of a group similar to the user data.

[0156] Below, we will look at an example of generating question-and-answer data using the personalized authentication method of the present invention.

[0157]

[0158] FIG. 9 is a block diagram illustrating an example of generating question-and-answer data in FIG. 5. FIG. 10 is a block diagram illustrating an example of the Q generation module or QA generation module of FIG. 9. FIG. 11 is a diagram illustrating an example of generating question-and-answer data according to a personalized authentication method according to an embodiment of the present invention. In the following, any content that overlaps with the above will be briefly explained, with a focus on differences.

[0159] As described above, the server (100) can classify attributes of user data and select the correct answer (A) from the user data based on the classified attributes. Below, an example of generating question-and-answer data (QnA) using a common attribute (M) among the classified attributes will be described.

[0160] Here, common attributes (M) refer to attributes that can be anonymized or pseudonymized in table data, such as columns corresponding to gender, age, consumption patterns, or meta-categories. In this case, table data includes user data, and may also include similar data similar to user data, but it is understood that only user data can be included and utilized.

[0161] At this time, common attributes (M) and correct answers (A) are input to the preprocessing module (PM), and merged data (M+A) generated based on the common attributes (M) and correct answers (A) can be derived as the output of the preprocessing module (PM).

[0162] Next, the server (100) extracts a first sample question (Qr) related to the merged data (M+A) from the QA database (QADB) using the merged data (M+A) output from the preprocessing module (PM).

[0163] Additionally, the server (100) inputs merged data (M+A) into the Q generation module (QGM) and obtains a second sample question (Qg) as an output thereof.

[0164] Next, the server (100) merges the first sample question (Qr), the second sample question (Qg), and the correct answer (A) and inputs them into the QA generation module (QAGM), and obtains temporary question-and-answer data (QnA_t) as an output thereof.

[0165] Here, the Q generation module (QGM) and the QA generation module (QAGM) can be configured to include a deep learning model.

[0166]

[0167] Specifically, the deep learning models included in the Q Generation Module (QGM) and QA Generation Module (QAGM) are implemented as neural network structures and can train an artificial neural network using mapping values ​​for separate parameters derived from input data. At this time, the deep learning model can perform machine learning on the parameters input as learning factors.

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

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

[0170] Deep learning models can utilize a variety of well-known artificial neural network structures. For example, deep learning models can include convolutional neural networks (CNNs), recurrent neural networks (RNNs), deep belief networks (DBNs), and graph neural networks (GNNs).

[0171] Meanwhile, artificial neural network training in deep learning models can be achieved by adjusting the weights of connections between nodes (and, if necessary, bias values) to ensure the desired output for a given input. Furthermore, artificial neural networks can continuously update weight values ​​through learning. Furthermore, methods such as backpropagation can be used for artificial neural network training.

[0172] At this time, an artificial neural network (ANN) pre-trained through machine learning may be installed in the memory (140) of the server (100). That is, data used in machine learning and result data, etc. may be stored in the memory (140).

[0173] In some embodiments of the present invention, the deep learning model may include a generative AI model based on a Transformer or a Large Language Model, including an encoder and decoder. However, these are merely some examples of the present invention, and the present invention is not limited thereto.

[0174] Referring to Figure 10, the deep learning model includes an input layer (input) that uses text-type prompts as input nodes, an output layer (Output) that uses question-and-answer data as output nodes, and M hidden layers positioned between the input layer and the output layer.

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

[0176] Before a deep learning model begins training, all nodes and edges can be set to initial values. However, as information accumulates, the weights of nodes and edges change. This process can create a match between the parameters input as learning factors (i.e., character recognition data) and the values ​​assigned to output nodes (i.e., summary data).

[0177] Additionally, when utilizing a cloud server (not shown) (e.g., database (400)), the deep learning model can receive and process a large number of parameters. In some embodiments of the present invention, the operation of the deep learning model may be performed in conjunction with the server (100) and / or a separate cloud server (not shown). Accordingly, the deep learning model can perform learning based on a large amount of data.

[0178] The weights of the nodes and edges between the input and output nodes that make up a deep learning model can be updated during the deep learning model's training process. Furthermore, the parameters output from a deep learning model can be expanded to include a variety of data beyond summary data.

[0179] Deep learning models can utilize both semi-supervised and supervised learning as machine learning methods. Furthermore, deep learning models can be controlled to automatically update their artificial neural network structures after training, depending on the settings, to produce more accurate question-and-answer data.

[0180]

[0181] Referring again to FIG. 9, the server (100) inputs the temporary question-and-answer data (QnA_t) output from the QA generation module (QAGM) into the question update module (QUM), and obtains question-and-answer data (QnA) as an output thereof. At this time, the question update module (QUM) receives a predetermined question difficulty (QD) as input, and compares the input question difficulty (QD) with the generation difficulty of the temporary question-and-answer data (QnA_t) to determine whether to update the temporary question-and-answer data (QnA_t).

[0182] Specifically, when the generation difficulty is the same as the question difficulty, the question update module (QUM) can output the temporary question-and-answer data (QnA_t) generated by the QA generation module (QAGM) as question-and-answer data (QnA) as it is. On the other hand, when the generation difficulty is different from the question difficulty, the question update module (QUM) can update the choices included in the question of the temporary question-and-answer data (QnA_t) generated by the QA generation module (QAGM). At this time, the question update module (QUM) can regenerate the incorrect answer choices for the temporary question-and-answer data (QnA_t) to correspond to the question difficulty, and output the question-and-answer data (QnA) with the regenerated incorrect answer choices updated in the temporary question-and-answer data (QnA_t).

[0183] At this time, the question update module (QUM) can regenerate incorrect answer choices using data corresponding to predetermined attributes (e.g., common attributes (M)) of clusters or similar data included in the clusters, which are assigned difficulty tags similar to the question difficulty (QD). However, this is merely one example of generating incorrect answer choices, and the present invention is not limited thereto.

[0184]

[0185] As another example, referring to FIG. 11, the QA generation module (QAGM) includes a generative AI model, and input data in the form of a prompt can be accepted, and question-and-answer data can be output as an output.

[0186] Specifically, the QA generation module (QAGM) may input a sample question (Qr+Qg) in which the first sample question (Qr) and the second sample question (Qg) derived in the aforementioned manner are merged, and data in which a predetermined attribute (e.g., common attribute (M)) and the correct answer (A) are merged, and temporary question-and-answer data (QnA_t) may be derived as an output thereof.

[0187] For example, as illustrated in FIG. 11, the first sample question (Qr) and the second sample question (Qg) constituting the sample question (Qr+Qg) may be in the form of multiple choice questions including multiple choices, and the first sample question (Qr) and the second sample question (Qg) may be connected and input to the QA generation module (QAGM).

[0188] In addition, information corresponding to predefined attributes can be combined with information included in common attributes (M), such as gender (e.g., male), time (e.g., yesterday morning), region (e.g., Seoul), payment amount (e.g., 5,000 won), and payment method (e.g., Samsung Card), and information about the correct answer (A) (e.g., Starbucks) selected from the user data in the aforementioned manner, and input into the QA generation module (QAGM).

[0189] Although not explicitly disclosed in the drawing, data for sample questions (Qr+Qg) and common attributes and correct answers (M+A) input to the QA generation module (QAGM) can be input along with a prompt requesting the generation of temporary question-and-answer data (QnA_t).

[0190] At this time, the temporary question and answer data (QnA_t) output from the QA generation module (QAGM) can be generated in the same objective question format as the first sample question (Qr) and the second sample question (Qg).

[0191] Next, the question update module (QUM) receives the temporary question and answer data (QnA_t) output from the QA generation module (QAGM) and the question difficulty (QD) of the question and answer data (QnA) to be provided to the user terminal (200). At this time, the question update module (QUM) can determine whether to update the incorrect answer choices included in the temporary question and answer data (QnA_t) based on whether the generation difficulty of the input temporary question and answer data (QnA_t) matches the input question difficulty (QD). A detailed description thereof has been described above with reference to FIG. 8, and thus, a redundant description will be omitted.

[0192] Next, the server (100) can perform user authentication by providing a question included in the question and answer data (QnA) output from the question update module (QUM) to the user terminal (200) and comparing the answer received from the user terminal (200) with the correct answer (A).

[0193] Through this, the server (100) that performs the personalized authentication method according to the present invention can provide a more secure non-face-to-face financial business environment to the user by generating question-and-answer data based on user data and using it for user authentication.

[0194] In addition, the server (100) of the present invention can provide question-and-answer data in a more discriminatory and diverse form to the user terminal than the conventional technique of using question-and-answer data stored in advance in a database by generating incorrect answer data according to the question difficulty determined based on data of a group similar to the user data.

[0195] Below, a personalized authentication method according to another embodiment of the present invention will be examined in detail.

[0196]

[0197] Figure 12 is a flowchart of a personalized authentication method according to another embodiment of the present invention. Figure 13 is a flowchart of a personalized authentication method according to yet another embodiment of the present invention. Similarly, the following description will omit any overlap with the previously described content and focus on the differences.

[0198] First, referring to FIG. 12, in a personalized authentication method according to another embodiment of the present invention, a server (100) collects user data from a user terminal (200) (S100).

[0199] Next, the server (100) classifies the attributes of the collected user data (S510).

[0200] Next, the server (100) selects the correct answer (A) within the user data based on the attributes of the classified user data (S520).

[0201] Next, the server (100) extracts a first sample question (Qr) from a list of questions pre-stored in a QA database (QADB) or generates a second sample question (Qg) using a Q generation module (QGM) including a deep learning model (S535).

[0202] Next, the server (100) generates question-and-answer data using a QA generation module (QAGM) including a deep learning model based on at least one of the first sample question (Qr) and the second sample question (Qg) and the correct answer (A) (S555).

[0203] Next, the server (100) provides the question included in the generated question-and-answer data to the user terminal (200) (S600).

[0204] Next, the server (100) can perform user authentication by receiving an answer to a question from the user terminal (200) and determining whether it matches the correct answer included in the question-and-answer data.

[0205]

[0206] Additionally, referring to FIG. 13, in another embodiment of the present invention, the server (100) determines the question difficulty level to be provided to the user terminal (200) based on user data following step S555 (S400). At this time, the server (100) may determine the question difficulty level of the question-and-answer data to be provided to the user terminal (200) based on the user's activity data using the user terminal (200) or the need for enhanced authentication.

[0207] Next, the server (100) determines the difficulty of generating the question-and-answer data generated in step S555 (S560).

[0208] Next, the server (100) compares the difficulty of generating the question-and-answer data with the difficulty of the question to be provided to the user terminal (200) to determine whether to update the incorrect answer choices for the question-and-answer data (S570).

[0209] Unlike the aforementioned embodiment of the present invention, the personalized authentication method according to some other embodiments of the present invention can generate question-and-answer data using only user data, regardless of similar data related to the user data, and can generate question-and-answer data with different question difficulties based on the user's activity level for an application installed on the user terminal or the need for enhanced authentication of a service to be provided.

[0210] Through this, the personalized authentication method according to the present invention can provide question-and-answer data suitable for the service currently being used by the user to the user terminal, and can optimize the system resources required to generate the question-and-answer data.

[0211]

[0212] FIG. 14 is a diagram for explaining an example of question-and-answer data provided to a user terminal in step S600 of FIG. 3 or FIG. 12. FIG. 15 is a diagram for explaining another example of question-and-answer data provided to a user terminal in step S600 of FIG. 3 or FIG. 12.

[0213] Referring to FIG. 14, the server (100) may provide a chat interface on the screen (210) of the user terminal (200). In the chat interface, a sentence (iQ) that initially prompts the user to ask a question may be displayed.

[0214] Next, if there is no user input for a predetermined period of time, the server (100) may generate question-and-answer data (QnA_T1) based on previously received user data and provide it to the screen (210) of the user terminal (200). For example, if there is no separate chat input by the user on the chat interface, the server (100) may determine that the user's activity data is lower than a predetermined standard, and randomly determine the question difficulty of the question-and-answer data (QnA_T1).

[0215] Next, the server (100) can generate question-and-answer data (QnA_T1) corresponding to the determined question difficulty. At this time, the server (100) can generate question-and-answer data (QnA_T1) using only previously received user data, or using similar data that is associated with the user data and has been assigned a difficulty tag corresponding to the determined question difficulty. However, this is merely an example, and the present invention is not limited thereto.

[0216] Next, the server (100) determines, according to the type of pre-selected question and answer data, <b11>The choices included in the questions in the Q&A data (QnA_T1) are provided in text format, as shown below. <b12>As such, the choices included in the questions of the question-and-answer data (QnA_P) can be converted into images corresponding to the corresponding text and provided to the user terminal (200).

[0217]

[0218] As another example, in Fig. 15 <b21>Referring to , the server (100) may provide a chat interface on the screen (210) of the user terminal (200), and the user may transmit an input (rA1) including a specific request (e.g., please deposit yyy into account xxx) to the server (100) through the chat interface. For example, the server (100) may determine that the request for input received from the user terminal (200) requires enhanced authentication, and in this case, the server (100) may determine the question difficulty of the question-and-answer data (QnA_T1) to be generated as the first difficulty level, which is the most difficult.

[0219] Likewise, the server (100) can generate question-and-answer data (QnA_T1) corresponding to the determined question difficulty and provide the question included in the question-and-answer data (QnA_T1) on the screen (210) of the user terminal (200).

[0220] As another example, in Fig. 15 <b22>Referring to , if the input (rA1) received by the server (100) from the user terminal (200) is a type of service that can be authenticated with question-and-answer data, the server (100) can transmit a message (iQ2) asking whether to authenticate with question-and-answer data to the screen (210) of the user terminal (200).

[0221] Next, when receiving an input (rA2) requesting authentication with question-and-answer data from a user terminal (200), the server (100) may determine that the request for input received from the user terminal (200) requires enhanced authentication, and in this case, the server (100) may determine the question difficulty of the question-and-answer data (QnA_T1) to be generated as the first difficulty level, which is the most difficult.

[0222] Next, the server (100) can generate question-and-answer data (QnA_T1) corresponding to the determined question difficulty and provide it to the user terminal (200). Next, although not explicitly disclosed in the drawing, the server (100) can compare the answer to the question-and-answer data (QnA_T1) received from the user terminal (200) with the correct answer (A) to perform user authentication.

[0223] In summary, the personalized authentication method according to some embodiments of the present invention can simultaneously satisfy both enhanced security and user convenience in responding by generating question-and-answer data of different question difficulty levels according to the security level of the service provided to the user terminal and providing the data to the user terminal.

[0224]

[0225] FIG. 16 is a diagram illustrating a hardware implementation of a system that performs a personalized authentication method according to some embodiments of the present invention.

[0226] Referring to FIG. 16, a server (100) that performs a personalized authentication method according to some embodiments of the present invention may be implemented as an electronic device (1000). The electronic device (1000) may include a processor (1010), an input / output device (1020), a memory (1030), an interface (1040), storage (1050), and a bus (1060). The processor (1010), the input / output device (1020), the memory (1030), the interface (1040), and / or the storage (1050) may be coupled to each other via a bus (1060). The bus (1060) corresponds to a path through which data is transferred.

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

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

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

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

[0231] Storage (1050) can store and preserve data and / or programs. Storage (1050) may include one or more non-volatile memory devices, such as a solid state drive (SSD), a hard drive, or flash memory. In the present invention, storage (1050) may store a computer program comprising instructions for performing the aforementioned personalized authentication method.

[0232] The user terminal (200) can be applied to a personal digital assistant (PDA), a portable computer, a web tablet, a wireless phone, a mobile phone, a digital music player, a memory card, or any electronic product capable of transmitting and / or receiving information in a wireless environment.

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

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

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

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

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

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

[0239]

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

Claims

1. In a personalized authentication method performed on a server linked to a user terminal, A step of collecting user data about a user using the above user terminal; A step of extracting similar data related to the above user data; A step of creating at least one cluster for the above similar data and assigning a difficulty tag to the cluster; A step of determining the question difficulty of the question-and-answer data to be provided to the user terminal based on the user data; A step of generating question and answer data including questions and answers corresponding to the above question difficulty level; and A step of providing the question included in the generated question-and-answer data to the user terminal. Personalized authentication method.

2. In paragraph 1, The steps for generating the above Q&A data are: A step of classifying attributes from the above user data; A step of selecting the correct answer (A) from the user data based on the classified attributes; A step of extracting a first sample question (Qr) from a list of pre-saved questions; A step of generating a second sample question (Qg) using a deep learning model; and A step of generating the question-and-answer data using a deep learning model based on the first sample question (Qr), the second sample question (Qg), and the correct answer (A). Personalized authentication method.

3. In paragraph 2, The steps for generating the above Q&A data are: A step of determining the difficulty of generating the generated question and answer data; If the above question difficulty and the above generation difficulty are the same, a step of using the generated question and answer data as is; and If the above question difficulty level and the above generation difficulty level are different, the method further includes a step of updating the incorrect answer choices included in the generated question-and-answer data. Personalized authentication method.

4. In paragraph 3, The steps to update the above incorrect answer choices are: A step of deriving incorrect answer choices using similar data of the cluster to which the difficulty tag corresponding to the question difficulty is assigned; and Including a step of updating the question and answer data so that the derived incorrect answer choices are reflected. Personalized authentication method.

5. In paragraph 2, The above properties are classified as binary-category, multi-category or meta-category, The above multi-category includes columns related to amount or product type, The above meta-category includes columns related to time, gender, age, region or payment method. Personalized authentication method.

6. In paragraph 2, The above user data is, Personal information including information about the user's age, income, gender, occupation or location; Financial activity information including financial product subscription information, transfer information, existence of a bankbook, payment amount, product usage information, or financial application usage information Personalized authentication method.

7. In paragraph 1, The step of assigning difficulty tags to the above clusters is: Comprising determining a difficulty tag of the cluster by comparing the first distance between the user data and the cluster and a predetermined range criterion. Personalized authentication method.

8. In paragraph 7, The step of assigning difficulty tags to the above clusters is: If the first distance is less than the first range criterion, a step of assigning a first difficulty, which is the most difficult difficulty, to the difficulty tag of the cluster; If the first distance exceeds the first range criterion and is less than the second range criterion, a step of assigning a second difficulty that is easier than the first difficulty to the difficulty tag of the cluster; and If the first distance exceeds the second range criterion, a step of assigning a third difficulty level that is easier than the second difficulty level to the difficulty tag of the cluster is included. Personalized authentication method.

9. In paragraph 1, The step of determining the question difficulty of the above Q&A data is: A step of determining the question difficulty of the Q&A data based on the user's activity data or the need for enhanced authentication. Personalized authentication method.

10. In paragraph 9, The step of determining the question difficulty of the above Q&A data is: If the above activity data is less than a predetermined standard, a step of randomly determining the question difficulty of the question-and-answer data; and If the above activity data is greater than a predetermined reference value, a step of determining the question difficulty of the question-and-answer data as a predetermined second difficulty level is included. Personalized authentication method.

11. In paragraph 10, The above activity data includes the number of times an application operated on the server is used or the accumulated amount of data entered from the user terminal through the application. The above criteria are determined based on personal information including the user's gender, age, or region. Personalized authentication method.

12. In paragraph 9, The step of determining the question difficulty of the above Q&A data is: In case there is a need for enhanced authentication in the service provided by the user terminal, a step of determining the question difficulty of the question-and-answer data as the first difficulty, which is the most difficult difficulty is included. Personalized authentication method.

13. In paragraph 1, The step of providing the above question to the user terminal is: A step of providing the choices included in the above question in the form of text or converting them into an image corresponding to the text Personalized authentication method.

14. In paragraph 1, The above Q&A data is, Multiple choice question and answer data consisting of questions and correct answers with multiple choices, or Contains subjective question and answer data consisting of questions and answers that do not include multiple choices. Personalized authentication method.

15. In a personalized authentication method performed on a server linked to a user terminal, A step of collecting user data about a user using the above user terminal; A step of generating question-and-answer data including questions and answers related to the above user data; and Including a step of providing a question included in the above Q&A data to the user terminal, The steps for generating the above Q&A data are: A step of classifying attributes from the above user data; A step of selecting the correct answer (A) from the user data based on the classified attributes; A step of extracting a first sample question (Qr) from a list of pre-saved questions or generating a second sample question (Qg) using a deep learning model; and A step of generating the question-and-answer data using a deep learning model based on at least one of the first sample question (Qr) and the second sample question (Qg) and the correct answer (A). Personalized authentication method.

16. In paragraph 1, The steps for generating the above Q&A data are: A step of determining the question difficulty of the question-and-answer data to be provided to the user terminal based on the user data; A step of determining the difficulty of generating the generated question and answer data; If the above question difficulty and the above generation difficulty are the same, a step of using the generated question and answer data as is; and If the above question difficulty level and the above generation difficulty level are different, the method further includes a step of updating the incorrect answer choices included in the generated question-and-answer data. Personalized authentication method.

17. Processor; a memory for loading a computer program executed by the processor; and Including an interface for exchanging data generated during the execution of the above computer program with a user terminal, The above computer program, A step of collecting user data about a user using the above user terminal; A step of extracting similar data related to the above user data; A step of creating at least one cluster for the above similar data and assigning a difficulty tag to the cluster; A step of determining the question difficulty of the question-and-answer data to be provided to the user terminal based on the user data; A step of generating question and answer data including questions and answers corresponding to the above question difficulty level; and A step of providing the question included in the generated question-and-answer data to the user terminal. Server.

18. A computer-readable recording medium recording a program capable of executing the method described in any one of paragraphs 1 to 16.

Images