Search result provision method and system

Abstract

Disclosed is a search result provision method performed by at least one processor, comprising the steps of: receiving a natural language query; generating graph data through a machine learning model on the basis of the natural language query; acquiring a first embedding vector from the generated graph data by using a graph embedding algorithm; identifying an index from an index database on the basis of the acquired first embedding vector; extracting data from a source database on the basis of the identified index; and providing a search result for the natural language query on the basis of the extracted data.

Description

Method and system for providing search results

[0001] The present disclosure relates to a method and system for providing search results.

[0002] Database technologies are constantly evolving to manage the increasing volume and diverse data formats. Among these database technologies, data retrieval using indexes is a key technology for efficiently processing required data in databases and providing users with quick search results.

[0003] Meanwhile, in recent search scenarios, interest has grown beyond simply processing data identical or similar to the search term (or query) to provide search results that align with the user's intent. This shift goes beyond understanding the meaning of the query and processing data that aligns with that meaning, thereby providing search results that align with the user's intent. Accordingly, for these search scenarios, there is a growing demand for index processing technology that can process user-entered queries and retrieve data based on the processed results.

[0004] The present disclosure provides a method and system for providing search results to solve the above problems.

[0005] The present disclosure can be implemented in various ways, including a computer-readable, non-transitory recording medium having recorded thereon methods, devices (systems), and / or instructions.

[0006] According to one embodiment of the present disclosure, a method for providing search results, performed by at least one processor, may include the steps of receiving a natural language query, generating graph data through a machine learning model based on the natural language query, obtaining a first embedding vector from the generated graph data using a graph embedding algorithm, identifying an index in an index database based on the obtained first embedding vector, extracting data from a source database based on the identified index, and providing a search result for the natural language query based on the extracted data.

[0007] In one embodiment, a machine learning model can be trained to generate a plurality of entities and relationships between the plurality of entities associated with a natural language query from a natural language query.

[0008] According to one embodiment, the machine learning model can be trained to add an entity corresponding to at least one of a synonym, an analogue, or an expression representing a context determined based on the natural language query to a plurality of entities.

[0009] In one embodiment, the machine learning model can be trained to change an entity corresponding to a keyword extracted from a natural language query among a plurality of entities into an entity corresponding to a synonym of the keyword.

[0010] According to one embodiment, the method for providing search results may further include a step of displaying graph data.

[0011] According to one embodiment, a method for providing search results may further include receiving user input for deleting, adding, or changing at least one entity or relationship between entities associated with graph data, and restructuring the graph data based on the received user input.

[0012] According to one embodiment, the index database has a graph data structure and may include a second embedding vector obtained using a graph embedding algorithm as an index for each node of graph data included in the index database.

[0013] According to one embodiment, the step of identifying an index may include the step of calculating a similarity between a first embedding vector and a second embedding vector, and the step of identifying an index in an index database based on the calculated similarity.

[0014] According to one embodiment of the present disclosure, a computer-readable non-transitory recording medium storing one or more computer programs including commands for performing the above-described search result providing method may be provided.

[0015] According to one embodiment of the present disclosure, a system includes a memory, and at least one processor coupled to the memory and configured to execute at least one computer-readable program contained in the memory, wherein the at least one program may include instructions for receiving a natural language query, generating graph data through a machine learning model based on the natural language query, obtaining an embedding vector from the generated graph data using a graph embedding algorithm, identifying an index in an index database based on the obtained embedding vector, extracting data from a source database based on the identified index, and providing a search result for the natural language query based on the extracted data.

[0016] According to some embodiments of the present disclosure, search results that match a user's intention can be provided by searching data through a graph embedding vector obtained based on a natural language query.

[0017] The effects of the present disclosure are not limited to the effects mentioned above, and other effects not mentioned can be clearly understood by a person having ordinary knowledge in the technical field to which the present disclosure belongs (referred to as “ordinary skilled person”) from the description of the claims.

[0018] Embodiments of the present disclosure will be described below with reference to the accompanying drawings, wherein like reference numerals represent similar elements, but are not limited thereto.

[0019] FIG. 1 is a diagram exemplarily illustrating a method for providing search results according to one embodiment of the present disclosure.

[0020] FIG. 2 is a schematic diagram showing a configuration in which an information processing system is connected to enable communication with a plurality of user terminals in relation to providing search results according to one embodiment of the present disclosure.

[0021] FIG. 3 is a block diagram showing the internal configuration of a user terminal and an information processing system according to one embodiment of the present disclosure.

[0022] FIG. 4 is a drawing for explaining a device configuration for providing search results according to one embodiment of the present disclosure.

[0023] FIG. 5 is a diagram for explaining a device configuration for processing data according to one embodiment of the present disclosure.

[0024] FIG. 6 is a diagram illustrating a method for generating graph data based on a natural language query and obtaining an embedding vector from the graph data according to one embodiment of the present disclosure.

[0025] FIG. 7 is a diagram illustrating a method for adding an entity node to graph data according to one embodiment of the present disclosure.

[0026] FIG. 8 is a diagram illustrating a method for replacing an entity node included in graph data with another entity node according to one embodiment of the present disclosure.

[0027] FIG. 9 is a diagram illustrating a method for restructuring graph data based on user input according to one embodiment of the present disclosure.

[0028] FIG. 10 is a drawing for explaining a method for providing search results according to one embodiment of the present disclosure.

[0029] Hereinafter, specific details for implementing the present disclosure will be described in detail with reference to the attached drawings. However, in the following description, specific descriptions of widely known functions or configurations will be omitted if they may unnecessarily obscure the gist of the present disclosure.

[0030] In the attached drawings, identical or corresponding components are assigned the same reference numerals. Furthermore, in the description of the embodiments below, duplicate descriptions of identical or corresponding components may be omitted. However, even if a description of a component is omitted, it is not intended that such component is not included in any embodiment.

[0031] The advantages and features of the disclosed embodiments, and methods for achieving them, will become clearer with reference to the embodiments described below, along with the accompanying drawings. However, the present disclosure is not limited to the embodiments disclosed below and may be implemented in various different forms. These embodiments are provided solely to ensure the completeness of the disclosure and to fully inform those skilled in the art of the scope of the invention.

[0032] The terms used in this specification will be briefly explained, followed by a detailed description of the disclosed embodiments. The terms used in this specification have been selected from widely used, current terms, taking into account the functions of the present disclosure. However, these terms may vary depending on the intentions of engineers working in the relevant field, precedents, the emergence of new technologies, etc. Furthermore, in certain cases, terms may be arbitrarily selected by the applicant, and in such cases, their meanings will be described in detail in the relevant description of the invention. Therefore, the terms used in this disclosure should not be defined simply as names of terms, but rather based on their meanings and the overall content of the present disclosure.

[0033] In this specification, singular expressions include plural expressions unless the context clearly indicates otherwise. Furthermore, plural expressions include singular expressions unless the context clearly indicates otherwise. When a part of the specification is said to include a component, this does not exclude other components, but rather implies that other components may be included, unless otherwise specifically stated.

[0034] Also, the term 'module' or 'part' used in the specification means a software or hardware component, and the 'module' or 'part' performs certain roles. However, the 'module' or 'part' is not limited to software or hardware. The 'module' or 'part' may be configured to reside on an addressable storage medium and may be configured to execute one or more processors. Thus, as an example, the 'module' or 'part' may include at least one of components such as software components, object-oriented software components, class components, and task components, processes, functions, attributes, procedures, subroutines, segments of program code, drivers, firmware, microcode, circuitry, data, databases, data structures, tables, arrays, or variables. The functionality provided within the components and 'modules' or 'parts' may be combined into a smaller number of components and 'modules' or 'parts', or further separated into additional components and 'modules' or 'parts'.

[0035] According to one embodiment of the present disclosure, a 'module' or 'unit' may be implemented as a processor and a memory. 'Processor' should be broadly construed to include a general-purpose processor, a central processing unit (CPU), a microprocessor, a digital signal processor (DSP), a controller, a microcontroller, a state machine, and the like. In some circumstances, a 'processor' may also refer to an application-specific integrated circuit (ASIC), a programmable logic device (PLD), a field-programmable gate array (FPGA), and the like. A 'processor' may also refer to a combination of processing devices, such as, for example, a combination of a DSP and a microprocessor, a combination of multiple microprocessors, a combination of one or more microprocessors in conjunction with a DSP core, or any other such combination of configurations. In addition, 'memory' should be broadly construed to include any electronic component capable of storing electronic information. 'Memory' may refer to various types of processor-readable media, such as random access memory (RAM), read-only memory (ROM), non-volatile random access memory (NVRAM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable PROM (EEPROM), flash memory, magnetic or marking data storage, registers, etc. Memory is said to be in electronic communication with the processor if the processor can read information from, and / or write information to, the memory. Memory integrated in a processor is in electronic communication with the processor.

[0036] In addition, terms such as first, second, A, B, (a), (b), etc. used in the following embodiments are only used to distinguish certain components from other components, and the nature, order, or sequence of the components are not limited by the terms.

[0037] Additionally, in the embodiments below, when it is described that a component is 'connected', 'coupled' or 'connected' to another component, it should be understood that the component may be directly connected or connected to the other component, but another component may also be 'connected', 'coupled' or 'connected' between each component.

[0038] Additionally, the terms 'comprises' and / or 'comprising' used in the following embodiments do not exclude the presence or addition of one or more other components, steps, operations and / or elements.

[0039] Hereinafter, various embodiments of the present disclosure will be described in detail with reference to the attached drawings.

[0040] FIG. 1 is a diagram exemplarily illustrating a method for providing search results according to one embodiment of the present disclosure. Referring to FIG. 1, when an information processing system receives a natural language query (110), it can generate graph data (122) through a machine learning model (120) based on the natural language query (110). For example, the information processing system can convert a natural language query (110) input by a user into a graph data structure. Here, the graph data structure can be a data structure that structures information and the interrelationships between information by expressing entities and relationships between entities as nodes and edges, respectively. In this way, by converting a natural language query (110) into a graph data structure identical or similar to an index database (140) according to one embodiment of the present disclosure, it can be easy to provide search results that meet the user's intention when searching for data using an index.

[0041] Meanwhile, the machine learning model (120) may include any model used to infer an answer for a given input. According to one embodiment, the machine learning model (120) may include an artificial neural network model including an input layer, multiple hidden layers, and an output layer. The artificial neural network model, as an example of the machine learning model (120), may refer to a statistical learning algorithm implemented based on the structure of a biological neural network or a structure that executes the algorithm in machine learning technology and cognitive science. For example, the artificial neural network model may refer to a machine learning model (120) having problem-solving capabilities by having nodes, which are artificial neurons that form a network by combining synapses like a biological neural network, repeatedly adjust the weights of synapses to learn so that the error between the correct output corresponding to a specific input and the inferred output is reduced. The artificial neural network model may include, for example, any probabilistic model used in artificial intelligence learning methods such as machine learning and deep learning, a neural network model, etc.

[0042] A machine learning model (120) according to one embodiment of the present disclosure may support a prompt, receive a natural language query (110), and generate graph data (122) based on the natural language query (110). For example, the machine learning model (120) may be trained to generate a plurality of entities and relationships between the plurality of entities associated with the natural language query (110) from the natural language query (110). In addition, the machine learning model (120) may set each of the plurality of entities as an entity node, and may set the relationships between the plurality of entities as edges, which are edges between the entity nodes.

[0043] According to one embodiment, in the process of generating graph data (122), the machine learning model (120) may be trained to add an entity corresponding to at least one of a synonym, a similar word, or an expression indicating a context determined based on the natural language query (110) of a keyword extracted from the natural language query (110) to a plurality of entities associated with the natural language query (110). For example, if the natural language query (110) includes “video,” entities of synonyms, similar words, or contextually corresponding expressions such as “image,” “frame,” or “file” may be added to the plurality of entities.

[0044] According to one embodiment, in the process of generating graph data (122), the machine learning model (120) may be trained to change an entity corresponding to a keyword extracted from a natural language query (110) among a plurality of entities associated with the natural language query (110) into an entity corresponding to a synonym of the keyword. For example, if the natural language query (110) includes “image” and the plurality of entities associated with the natural language query (110) include an entity corresponding to “image,” the entity corresponding to “image” may be changed (or replaced) into an entity corresponding to “image.”

[0045] According to one embodiment, when graph data (122) is generated, the information processing system can output (e.g., display) the generated graph data (122). For example, the information processing system can output the graph data (122) through an output device (e.g., a display). In some embodiments, the information processing system can transmit the graph data (122) to an external electronic device (e.g., a user terminal) including an output device, and the external electronic device that receives the graph data (122) can output the graph data (122) through the output device.

[0046] According to one embodiment, after the graph data (122) is output (e.g., displayed), the information processing system may receive user input for deleting, adding, or changing at least one of the entities or relationships between entities associated with the graph data (122). For example, while the graph data (122) is displayed on the screen of the display, the user may make an input (e.g., a touch, a drag, a gesture, etc.) for deleting, adding, or changing at least one of the entities or relationships between entities included in the graph data (122). At this time, if the information processing system displays the graph data (122) on a touch screen display, the information processing system may receive the user input through the touch screen display. Alternatively, if the graph data (122) is output to an output device of an external electronic device, the information processing system may receive the user input from the external electronic device. Then, the information processing system may restructure the graph data (122) based on the received user input. For example, the information processing system can reset entities and relationships between entities when at least one of the entities or relationships between entities included in the graph data (122) is deleted, added, or changed.

[0047] When graph data (122) is generated, the information processing system can obtain an embedding vector (132) from the generated graph data (122) using a graph embedding algorithm (130). Here, graph embedding represents (or converts) arbitrary graph data (e.g., graph data (122)) into a fixed-dimensional vector (e.g., embedding vector (132)), and can represent (or convert) a high-dimensional graph structure into a low-dimensional vector while preserving node similarity and structural information. For example, when an embedding vector is mapped to a point in a vector space, in the case of nodes with similar roles or connection relationships or graphs with similar structures, the points to which the embedding vector is mapped can be arranged adjacently in the vector space. The graph embedding algorithm (130) according to one embodiment of the present disclosure may use any graph embedding algorithm already known in the field related to graph embedding. For example, the graph embedding algorithm (130) may include Node2vec, DeepWalk, SDNE (Structural Deep Network Embedding), Graph2vec, etc.

[0048] Meanwhile, the data to be searched may be indexed in an index database (140) having a graph data structure. For example, the data's main keywords and metadata may be constructed in the index database (140) as a graph data structure. Here, the data may represent various types of documents or digitized resources. In addition, the metadata may include information such as data properties, the data's recording location (e.g., information about the source database (150) where the data is stored), etc.

[0049] According to one embodiment, the index database (140) may include data nodes associated with data, entity nodes associated with entities extracted from the data, and edges representing relationships between nodes. The data node may include an identifier of the data node and an identifier associated with the data. Here, the identifier associated with the data may represent an identifier for accessing data stored in the source database (150). For example, the identifier associated with the data may include a primary key for the data. In the following description, the identifier associated with the data is referred to as a first index (142). According to one embodiment, the data node may include an embedding vector for the data node. The embedding vector for the data node may include an embedding vector obtained from the data node using a graph embedding algorithm (e.g., the graph embedding algorithm (130)). The entity node may include an identifier of the entity node and an entity extracted from the data. Here, the entity may represent an object or concept extracted from data using a pre-trained machine learning model (e.g., machine learning model (120)). In addition, the pre-trained machine learning model may include a Large Language Model (LLM), etc. The Large Language Model may refer to a language model that can perform inference without fine-tuning using a method such as few-shot learning, and may have more than 10 times as many parameters (e.g., more than 100 billion parameters) as a conventional general language model. According to one embodiment, the entity node may include an embedding vector for the entity node. The embedding vector for the entity node may include an embedding vector obtained from the entity node using a graph embedding algorithm (e.g., graph embedding algorithm (130)).In the following description, an embedding vector for a node (e.g., an embedding vector for a data node and / or an embedding vector for an entity node) is referred to as a second index (144). To summarize, the index database (140) has a graph data structure and can include an embedding vector obtained using a graph embedding algorithm for each node (e.g., a data node and / or an entity node) of graph data included in the index database (140) as an index (e.g., the second index (144)).

[0050] Once the embedding vector (132) is obtained, the information processing system can identify an index (e.g., a first index (142)) in the index database (140) based on the embedding vector (132). For example, since a natural language query (110) is converted into graph data (122) having a graph data structure identical or similar to that of the index database (140) and the embedding vector (132) is obtained from the graph data (122), the information processing system can identify an index (e.g., a first index (142)) by comparing the embedding vector (132) obtained based on the natural language query (110) (hereinafter, referred to as a first embedding vector) with an embedding vector (e.g., an embedding vector for a data node and / or an embedding vector for an entity node) (hereinafter, referred to as a second embedding vector) stored in the index database (140). According to one embodiment, the information processing system can calculate the similarity between the first embedding vector and the second embedding vector (i.e., the second index (144)) and identify an index (e.g., the first index (142)) corresponding to at least one second embedding vector having a high similarity. For example, the information processing system can select at least one node having a correlation based on the high similarity and identify an index corresponding to the selected at least one node. The similarity between vectors can be calculated through, for example, cosine similarity, Euclidean distance, Jaccard similarity, etc., but is not limited thereto.

[0051] Once an index (e.g., a first index (144)) is identified, the information processing system can extract data from a source database (150) based on the identified index and, based on the extracted data, provide a search result (152) for a natural language query (110). For example, the information processing system can provide the search result (152) to the user to include data associated with (e.g., referenced by) at least one node corresponding to the identified index.

[0052] As described above, since the natural language query (110) is converted into a graph data structure identical or similar to the index database (140) and searched, semantic processing including structure and relationships can be possible, and through this, search results that are more in line with the user's intention can be provided.

[0053] FIG. 2 is a schematic diagram illustrating a configuration in which an information processing system (230) is connected to a plurality of user terminals (210_1, 210_2, 210_3) so as to be able to communicate with each other in relation to providing search results according to one embodiment of the present disclosure. The information processing system (230) may include system(s) capable of providing a search service. In one embodiment, the information processing system (230) may include one or more server devices and / or databases capable of storing, providing, and executing computer-executable programs (e.g., downloadable applications) and data related to the search service, or one or more distributed computing devices and / or distributed databases based on a cloud computing service. For example, the information processing system (230) may include separate systems (e.g., servers) for the search service.

[0054] Search services, etc. provided by the information processing system (230) can be provided to users through search applications, web browser applications, etc. installed on each of a plurality of user terminals (210_1, 210_2, 210_3).

[0055] A plurality of user terminals (210_1, 210_2, 210_3) can communicate with an information processing system (230) via a network (220). The network (220) can be configured to enable communication between the plurality of user terminals (210_1, 210_2, 210_3) and the information processing system (230). Depending on the installation environment, the network (220) can be configured as a wired network such as Ethernet, a wired home network (Power Line Communication), a telephone line communication device, and RS-serial communication, a wireless network such as a mobile communication network, WLAN (Wireless LAN), Wi-Fi, Bluetooth, and ZigBee, or a combination thereof. The communication method is not limited, and may include not only a communication method utilizing a communication network (e.g., a mobile communication network, wired Internet, wireless Internet, broadcasting network, satellite network, etc.) that the network (220) may include, but also short-range wireless communication between user terminals (210_1, 210_2, 210_3).

[0056] For example, multiple user terminals (210_1, 210_2, 210_3) can transmit data search requests and commands associated with user requests for data search to an information processing system (230) via a network (220), and the information processing system (230) can receive them. For example, the information processing system (230) can receive a natural language query, a search request including a natural language query, and a command associated with the search request from at least one user terminal (210_1, 210_2, 210_3).

[0057] In FIG. 2, a mobile phone terminal (210_1), a tablet terminal (210_2), and a PC terminal (210_3) are illustrated as examples of user terminals, but are not limited thereto, and the user terminals (210_1, 210_2, 210_3) may be any computing device capable of wired and / or wireless communication and capable of installing and executing search applications, etc. For example, the user terminals may include smartphones, mobile phones, navigation devices, computers, laptops, digital broadcasting terminals, PDAs (Personal Digital Assistants), PMPs (Portable Multimedia Players), tablet PCs, game consoles, wearable devices, IoT (Internet of Things) devices, VR (virtual reality) devices, AR (augmented reality) devices, etc. In addition, although FIG. 2 illustrates three user terminals (210_1, 210_2, 210_3) communicating with the information processing system (230) via the network (220), this is not limited thereto, and a different number of user terminals may be configured to communicate with the information processing system (230) via the network (220).

[0058] FIG. 3 is a block diagram showing the internal configuration of a user terminal (210) and an information processing system (230) according to one embodiment of the present disclosure. The user terminal (210) may refer to any computing device capable of executing a search application, etc. and capable of wired / wireless communication, and may include, for example, a mobile phone terminal (210_1), a tablet terminal (210_2), a PC terminal (210_3) of FIG. 2. As illustrated, the user terminal (210) may include a memory (312), a processor (314), a communication module (316), and an input / output interface (318). Similarly, the information processing system (230) may include a memory (332), a processor (334), a communication module (336), and an input / output interface (338). As illustrated in FIG. 3, the user terminal (210) and the information processing system (230) may be configured to communicate information and / or data via a network (220) using respective communication modules (316, 336). In addition, the input / output device (320) may be configured to input information and / or data to the user terminal (210) or output information and / or data generated from the user terminal (210) via the input / output interface (318).

[0059] The memory (312, 332) may include any non-transitory computer-readable recording medium. According to one embodiment, the memory (312, 332) may include a permanent mass storage device such as a read-only memory (ROM), a disk drive, a solid-state drive (SSD), or flash memory. As another example, a permanent mass storage device such as a ROM, an SSD, a flash memory, or a disk drive may be included in the user terminal (210) or the information processing system (230) as a separate permanent storage device distinct from the memory. In addition, the memory (312, 332) may store an operating system and at least one program code (e.g., code for an application associated with a search service, etc.).

[0060] These software components may be loaded from a computer-readable recording medium separate from the memory (312, 332). This separate computer-readable recording medium may include a recording medium directly connectable to the user terminal (210) and the information processing system (230), and may include, for example, a computer-readable recording medium such as a floppy drive, a disk, a tape, a DVD / CD-ROM drive, a memory card, etc. As another example, the software components may be loaded into the memory (312, 332) through a communication module (316, 336) other than a computer-readable recording medium. For example, at least one program may be loaded into the memory (312, 332) based on a computer program (e.g., an application associated with a search service, etc.) that is installed by files provided by developers or a file distribution system that distributes installation files of applications through a network (220).

[0061] The processor (314, 334) may be configured to process instructions of a computer program by performing basic arithmetic, logic, and input / output operations. Instructions may be provided to the processor (314, 334) by a memory (312, 332) or a communication module (316, 336). For example, the processor (314, 334) may be configured to execute instructions received according to program code stored in a storage device such as the memory (312, 332).

[0062] The communication module (316, 336) may provide a configuration or function for the user terminal (210) and the information processing system (230) to communicate with each other via the network (220), and may provide a configuration or function for the user terminal (210) and / or the information processing system (230) to communicate with another user terminal or another system (e.g., a separate cloud system, etc.). For example, a request or data (e.g., a search request or data, etc.) generated by the processor (314) of the user terminal (210) according to a program code stored in a recording device such as a memory (312) may be transmitted to the information processing system (230) via the network (220) under the control of the communication module (316). Conversely, a control signal or command provided under the control of the processor (334) of the information processing system (230) can be received by the user terminal (210) through the communication module (316) of the user terminal (210) via the communication module (336) and the network (220).

[0063] The input / output interface (318) may be a means for interfacing with an input / output device (320). As an example, the input device may include a device such as a camera, a keyboard, a microphone, a mouse, etc., including an audio sensor and / or an image sensor, and the output device may include a device such as a display, a speaker, a haptic feedback device, etc. As another example, the input / output interface (318) may be a means for interfacing with a device that has a configuration or function integrated into one for performing input and output, such as a touch screen. In FIG. 3, the input / output device (320) is illustrated as not being included in the user terminal (210), but is not limited thereto and may be configured as a single device with the user terminal (210). In addition, the input / output interface (338) of the information processing system (230) may be a means for interfacing with a device (not shown) for input or output that is connected to the information processing system (230) or that the information processing system (230) may include. In FIG. 3, the input / output interface (318, 338) is illustrated as an element configured separately from the processor (314, 334), but is not limited thereto, and the input / output interface (318, 338) may be configured to be included in the processor (314, 334).

[0064] The user terminal (210) and the information processing system (230) may include more components than those shown in FIG. 3. However, it is not necessary to explicitly illustrate most of the conventional technical components. In one embodiment, the user terminal (210) may be implemented to include at least some of the input / output devices (320) described above. In addition, the user terminal (210) may further include other components such as a transceiver, a Global Positioning System (GPS) module, a camera, various sensors, a database, etc. For example, if the user terminal (210) is a smartphone, it may include components that a smartphone generally includes, and for example, various components such as an acceleration sensor, a gyro sensor, a microphone module, a camera module, various physical buttons, buttons using a touch panel, input / output ports, and a vibrator for vibration may be implemented to be further included in the user terminal (210).

[0065] According to one embodiment, the processor (314) of the user terminal (210) may be configured to operate a search application or web browser application that provides a search service. At this time, program code associated with the application may be loaded into the memory (312) of the user terminal (210). While the application is operating, the processor (314) of the user terminal (210) may receive information and / or data provided from the input / output device (320) through the input / output interface (318) or may receive information and / or data from the information processing system (230) through the communication module (316), and may process the received information and / or data and store it in the memory (312). In addition, such information and / or data may be provided to the information processing system (230) through the communication module (316).

[0066] While the search application is running, the processor (314) may receive voice data, text, images, videos, etc. input or selected through input devices such as a camera, microphone, including a touch screen, keyboard, audio sensor, and / or image sensor connected to the input / output interface (318), and may store the received voice data, text, images, and / or videos in the memory (312) or provide them to the information processing system (230) through the communication module (316) and the network (220). In one embodiment, the processor (314) may receive user input input through the input device, and provide data / requests corresponding to the received user input to the information processing system (230) through the network (220) and the communication module (316).

[0067] The processor (314) of the user terminal (210) can output information and / or data by transmitting the information and / or data to an input / output device (320) through an input / output interface (318). For example, the processor (314) of the user terminal (210) can output the processed information and / or data through an output device (320), such as a display output capable device (e.g., a touch screen, a display, etc.) or a voice output capable device (e.g., a speaker).

[0068] The processor (334) of the information processing system (230) may be configured to manage, process, and / or store information and / or data received from multiple user terminals (210) and / or multiple external systems. Information and / or data processed by the processor (334) may be provided to the user terminal (210) via a communication module (336) and a network (220).

[0069] An information processing system (230) according to one embodiment of the present disclosure may be comprised of one or more electronic devices. The electronic devices may be of various types. The electronic devices may include, for example, portable communication devices (e.g., smartphones), computer devices, server devices, cloud devices, portable multimedia devices, portable medical devices, cameras, wearable devices, or home appliances. The electronic devices according to one embodiment of the present disclosure are not limited to the aforementioned devices.

[0070] FIG. 4 is a diagram illustrating a device configuration for providing search results according to one embodiment of the present disclosure. Referring to FIG. 4, the processor (334) of the information processing system (230) may include a query processing module (410) and a search result provision module (420). However, the types of modules included in the processor (334) are classified according to functions related to providing search results, and the types and number thereof are not limited thereto. In addition, at least one of the modules included in the processor (334) may be implemented in the form of instructions stored in the memory (332) of the information processing system (230).

[0071] The query processing module (410) can process a received natural language query (e.g., the natural language query (110) of FIG. 1). The query processing module (410) for processing a natural language query can include a graph transformation module (412) and a vector transformation module (414).

[0072] The query processing module (410) can convert a natural language query into a graph data structure through the graph transformation module (412). According to one embodiment, the graph transformation module (412) can generate graph data (e.g., graph data (122) of FIG. 1) based on input data (e.g., a natural language query) using a machine learning model (e.g., the machine learning model (120) of FIG. 1). For example, the graph transformation module (412) can generate a plurality of entities and relationships between the plurality of entities associated with the natural language query from the natural language query through the machine learning model, set each of the plurality of entities as an entity node, and set the relationships between the plurality of entities as edges, which are edges between the entity nodes. According to one embodiment, a logical data model can be used in the process of setting edges between nodes. Here, the logical data model can represent a model that expresses relationships between nodes according to a predefined schema (e.g., inclusion relationship, synonym relationship, connection relationship, dependency relationship, etc.).

[0073] In one embodiment, the graph transformation module (412) may generate data nodes associated with a natural language query. For example, the graph transformation module (412) may generate data nodes for the natural language query itself and establish edges representing relationships between entity nodes associated with entities extracted from the natural language query. Accordingly, graph data in a graph data structure based on data nodes associated with the natural language query may be generated.

[0074] According to one embodiment, the graph transformation module (412) may add related entities that are not included in the natural language query to the plurality of entities extracted from the natural language query through a machine learning model. For example, the graph transformation module (412) may add an entity corresponding to at least one of a synonym, an analogue, or an expression indicating a context determined based on the natural language query extracted from the natural language query to the plurality of entities associated with the natural language query through the machine learning model. According to one embodiment, the graph transformation module (412) may also change an entity corresponding to a keyword extracted from the natural language query among the plurality of entities associated with the natural language query into an entity corresponding to a synonym of the keyword through the machine learning model.

[0075] The query processing module (410) can convert graph data into a fixed-dimensional vector through the vector conversion module (414). According to one embodiment, the vector conversion module (414) can obtain an embedding vector (e.g., the embedding vector (132) of FIG. 1) from the graph data using a graph embedding algorithm (e.g., the graph embedding algorithm (130) of FIG. 1). For example, the vector conversion module (414) can convert a high-dimensional graph structure into a low-dimensional embedding vector while preserving the similarity and structural information of nodes included in the graph data. Accordingly, the embedding vector obtained from graph data generated based on a natural language query can support semantic processing by including the structure and relationship for the natural language query, while also supporting improved data processing performance (e.g., search speed).

[0076] The search result provision module (420) can provide search results using an embedding vector obtained based on a natural language query. The search result provision module (420) for providing search results may include a similarity calculation module (422) and a search result processing module (424).

[0077] The search result providing module (420) can obtain information about the search target data through the similarity calculation module (422). For example, the search result providing module (420) can identify an index of the search target data (e.g., the first index (142) of FIG. 1) through the similarity calculation module (422). According to one embodiment, the similarity calculation module (422) can identify an index by comparing an embedding vector obtained based on a natural language query (hereinafter referred to as a first embedding vector) with an embedding vector (e.g., an embedding vector for a data node and / or an embedding vector for an entity node) (hereinafter referred to as a second embedding vector) stored in an index database (e.g., an index database (140) of FIG. 1). According to one embodiment, the similarity calculation module (422) calculates the similarity between the first embedding vector and the second embedding vector (e.g., the second index (144) of FIG. 1) and can identify an index (e.g., the first index (142)) corresponding to at least one second embedding vector having a high similarity.

[0078] The search result provision module (420) can process search results through the search result processing module (424). According to one embodiment, the search result processing module (424) can extract data from a source database (e.g., the source database (150) of FIG. 1) based on an index identified through the similarity calculation module (422), and provide search results for a natural language query based on the extracted data.

[0079] FIG. 5 is a diagram illustrating a device configuration for processing data according to one embodiment of the present disclosure. Referring to FIG. 5, the processor (334) of the information processing system (230) may include a data processing module (510). However, the types of modules included in the processor (334) are classified according to functions related to data processing (e.g., database construction), and the types and numbers thereof are not limited thereto. In addition, at least one of the modules included in the processor (334) may be implemented in the form of instructions stored in the memory (332) of the information processing system (230).

[0080] The data processing module (510) can process data to be searched. For example, the data processing module (510) can store index information of the data to be searched in an index database (e.g., the index database (140) of FIG. 1). According to one embodiment, the index database can have a graph data structure. The data processing module (510) for data processing can include a graph transformation module (512) and a vector transformation module (514). The graph transformation module (512) and the vector transformation module (514) included in the data processing module (510) can perform functions identical or similar to those of the graph transformation module (412) and the vector transformation module (414) of the query processing module (410) described with reference to FIG. 4, respectively. However, the graph transformation module (412) and vector transformation module (414) of the query processing module (410) may have a natural language query as the target object (or data), and the graph transformation module (512) and vector transformation module (514) of the data processing module (510) may have a search target data as the target object.

[0081] The data processing module (510) can convert the search target data into a graph data structure through the graph transformation module (512). For example, the graph transformation module (512) can generate a data node associated with the data. The data node can include an identifier of the data node and an identifier associated with the data. Here, the identifier associated with the data is an identifier for accessing data stored in a source database (e.g., the source database (150) of FIG. 1) and can be referred to as a first index (e.g., the first index (142) of FIG. 1). For example, the identifier associated with the data can include a primary key for the data.

[0082] Additionally, the graph transformation module (512) can generate entity nodes by extracting entities from data. The entity nodes can include identifiers of the entity nodes and entities extracted from the data. Here, the entities can represent entities or concepts extracted from the data using a pre-trained machine learning model (e.g., the machine learning model (120) of FIG. 1). Furthermore, the pre-trained machine learning model can include a large-scale language model, etc.

[0083] Then, the graph transformation module (512) can generate graph data by connecting the generated data nodes and entity nodes with edges using a logical data model. Here, the logical data model can represent a model that expresses relationships between nodes according to a predefined schema (e.g., inclusion relationships, synonym relationships, connection relationships, dependency relationships, etc.). For example, the graph transformation module (512) can connect data nodes and entity nodes with edges having an "inclusion relationship" as an attribute.

[0084] The data processing module (510) can convert graph data into a vector of a fixed dimension through the vector conversion module (514). According to one embodiment, the vector conversion module (514) can generate an embedding vector for each node (e.g., a data node and / or an entity node) of the graph data using a graph embedding algorithm (e.g., the graph embedding algorithm (130) of FIG. 1). In addition, the vector conversion module (514) can add the generated embedding vector as a second index of each node (e.g., the second index (144) of FIG. 1). For example, each node of the graph data can include an embedding vector for the corresponding node as a second index.

[0085] FIG. 6 is a diagram illustrating a method for generating graph data based on a natural language query and obtaining an embedding vector from the graph data according to one embodiment of the present disclosure. Referring to FIG. 6, when an information processing system (e.g., the information processing system (230) of FIGS. 2 and 3) receives a natural language query (610) (e.g., the natural language query (110) of FIG. 1), the information processing system may generate graph data (e.g., the graph data (122) of FIG. 1) through a machine learning model (e.g., the machine learning model (120) of FIG. 1) based on the natural language query (610). In addition, the information processing system may obtain an embedding vector (632) (e.g., the embedding vector (132) of FIG. 1) from the generated graph data by using a graph embedding algorithm (e.g., the graph embedding algorithm (130) of FIG. 1). For example, the information processing system can convert a natural language query (610) into a graph data structure identical or similar to an index database (e.g., the index database (140) of FIG. 1). The graph data structure can represent a data structure that structures information and the interrelationships between information by expressing the relationships between entities as nodes and edges, respectively. Accordingly, when a natural language query (610) is converted into a graph data structure identical or similar to an index database and searched, semantic processing including structures and relationships can be enabled, so that search results that meet the user's intent can be provided.

[0086] The information processing system may generate, through a machine learning model, a plurality of entities (e.g., a first entity, a second entity, and a third entity) associated with a natural language query (610) and relationships between the plurality of entities from the natural language query (610), set each of the plurality of entities as an entity node (622, 624, 626), and set the relationships between the plurality of entities as edges, which are trunk lines between the entity nodes (622, 624, 626). According to one embodiment, the information processing system may generate a data node (620) associated with the natural language query (610). For example, the information processing system can create a data node (620) for the natural language query (610) itself, and set edges (622a, 624a, 626a) indicating relationships with entity nodes (622, 624, 626) associated with entities extracted from the natural language query (610). Accordingly, graph data of a graph data structure based on the data node (620) associated with the natural language query (610) can be created. In FIG. 6, a first entity node (622), a second entity node (624), and a third entity node (626) are shown in a state in which they are connected to the data node (620) in an inclusion relationship. For example, a state is shown in which a first entity node (622), a second entity node (624), and a third entity node (626) are connected to a data node (620) via a first edge (622a), a second edge (624a), and a third edge (626a), respectively. However, the structure of the graph, such as the number of nodes and the connection relationship, is not limited thereto.

[0087] Then, the information processing system can convert the high-dimensional graph structure into a low-dimensional embedding vector (632) while preserving the similarity and structural information of the nodes included in the graph data. Accordingly, the embedding vector (632) obtained from the graph data generated based on the natural language query (610) can support semantic processing by including the structure and relationships for the natural language query (610), while also supporting improved data processing performance (e.g., search speed).

[0088] According to one embodiment, the embedding vector (632) obtained from the graph data may include at least one of an embedding vector for the entire graph structure, an embedding vector for a sub-structure (or sub-graph) of the graph, or an embedding vector for each node of the graph. The type of such embedding vector may vary depending on the graph embedding algorithm. The graph embedding algorithm may include, for example, Node2vec, DeepWalk, SDNE, Graph2vec, etc.

[0089] FIG. 7 is a diagram illustrating a method for adding an entity node to graph data according to one embodiment of the present disclosure. Referring to FIG. 7, when an information processing system (e.g., the information processing system (230) of FIGS. 2 and 3) receives a natural language query (610) (e.g., the natural language query (110) of FIG. 1), the information processing system may generate graph data (e.g., the graph data (122) of FIG. 1) through a machine learning model (e.g., the machine learning model (120) of FIG. 1) based on the natural language query (610). In addition, in the process of generating the graph data, the information processing system may add a related entity that is not included in the natural language query (610) to a plurality of entities extracted from the natural language query (610). For example, the information processing system may add an entity corresponding to at least one of a synonym, a similar word, or an expression indicating a context determined based on the natural language query (610) extracted from the natural language query (610) through a machine learning model to a plurality of entities associated with the natural language query (610). In FIG. 7, a first entity node (622), a second entity node (624), and a third entity node (626) are connected to the data node (620) in an inclusion relationship, and then a fourth entity node (628) is added. For example, a first entity node (622), a second entity node (624), and a third entity node (626) are connected to a data node (620) via a first edge (622a), a second edge (624a), and a third edge (626a), respectively, and then a fourth entity node (628) is connected to the third entity node (626) via a fourth edge (628a). The fourth edge (628a) may have properties such as, for example, a “synonym relationship,” a “synonym relationship,” a “connection relationship,” a “dependency relationship,” etc. However, the structure of the graph, for example, the number of nodes and the connection relationship, is not limited thereto.

[0090] After entity nodes are added to the graph data, the information processing system can obtain an embedding vector (634) (e.g., the embedding vector (132) of FIG. 1) from the graph data using a graph embedding algorithm (e.g., the graph embedding algorithm (130) of FIG. 1). Since the graph structure in FIG. 7 is different from the graph structure in FIG. 6, the embedding vector obtained from the graph data may also be different. For example, the embedding vector (634) of FIG. 7 may be different from the embedding vector (632) of FIG. 6. In this way, by adding entity nodes, the information processing system can generate various graph data, and can support more diverse data searches suitable for the user's intention by using the embedding vectors obtained from the various graph data.

[0091] FIG. 8 is a diagram illustrating a method for replacing an entity node included in graph data with another entity node according to one embodiment of the present disclosure. Referring to FIG. 8, when an information processing system (e.g., the information processing system (230) of FIGS. 2 and 3) receives a natural language query (610) (e.g., the natural language query (110) of FIG. 1), the information processing system may generate graph data (e.g., the graph data (122) of FIG. 1) through a machine learning model (e.g., the machine learning model (120) of FIG. 1) based on the natural language query (610). In addition, in the process of generating the graph data, the information processing system may replace at least one entity among a plurality of entities associated with the natural language query (610) with a new entity. For example, the information processing system may change an entity corresponding to a keyword extracted from a natural language query (610) among a plurality of entities associated with a natural language query (610) into an entity corresponding to a synonym of the keyword. In FIG. 8, a first entity node (622), a second entity node (624), and a third entity node (626) are connected to a data node (620) in an inclusion relationship, and then the third entity node (626) is changed to a fourth entity node (628). For example, after the first entity node (622), the second entity node (624), and the third entity node (626) are connected to the data node (620) through the first edge (622a), the second edge (624a), and the third edge (626a), respectively, the third entity node (626) is changed to the fourth entity node (628). At this time, the third edge (626a) connecting the data node (620) and the third entity node (626) can be connected as is without being changed to the data node (620) and the fourth entity node (628). In this way, only the nodes can be changed without changing the entire structure of the graph. Similarly, the structure of the graph, for example, the number of nodes and the connection relationship, is not limited thereto.

[0092] After entity nodes are replaced (or changed) in the graph data, the information processing system can obtain an embedding vector (636) (e.g., the embedding vector (132) in FIG. 1) from the graph data using a graph embedding algorithm (e.g., the graph embedding algorithm (130) in FIG. 1). The graph structure in FIG. 8 is the same or similar to the graph structure in FIG. 6, but since the nodes are different, the embedding vector obtained from the graph data may also be different. For example, the embedding vector (636) in FIG. 8 may be different from the embedding vector (632) in FIG. 6. In this way, through the replacement (or change) of entity nodes, the information processing system can generate various graph data, and can support more diverse data searches suitable for the user's intention by using the embedding vectors obtained from the various graph data.

[0093] FIG. 9 is a diagram illustrating a method for restructuring graph data based on user input according to one embodiment of the present disclosure. Referring to FIG. 9, an information processing system (e.g., the information processing system (230) of FIGS. 2 and 3) can restructure graph data (e.g., graph data (122) of FIG. 1) generated through a machine learning model (e.g., the machine learning model (120) of FIG. 1) based on a natural language query (e.g., the natural language query (110) of FIG. 1). In more detail, when graph data is generated, the information processing system can output (e.g., display) the generated graph data. For example, the information processing system can output the graph data through an output device (e.g., a display). In some embodiments, the information processing system can transmit graph data to an external electronic device (e.g., a user terminal) including an output device, and the external electronic device that receives the graph data can output the graph data through the output device.

[0094] According to one embodiment, after graph data is output (e.g., displayed), the information processing system may receive user input for deleting, adding, or modifying at least one entity or relationship between entities associated with the graph data. For example, while the graph data is displayed on a screen of a display, a user may make an input (e.g., a touch, a drag, a gesture, etc.) for deleting, adding, or modifying at least one entity or relationship between entities included in the graph data. At this time, if the information processing system displays the graph data on a touch screen display, the information processing system may receive the user input through the touch screen display. Alternatively, if the graph data is output to an output device of an external electronic device, the information processing system may receive the user input from the external electronic device. Then, the information processing system may restructure the graph data based on the received user input. For example, if at least one entity or relationship between entities included in the graph data is deleted, added, or modified, the information processing system may reconfigure the entities and the relationships between the entities.

[0095] In FIG. 9, graph data generated based on a natural language query includes a data node (900), a first entity node (910), a second entity node (920), a third entity node (930), a fourth entity node (940), and a fifth entity node (950), and the structure is illustrated in which the first entity node (910), the second entity node (920), and the third entity node (930) are connected to the data node (900) via a first edge (912), a second edge (922), and a third edge (932), respectively, and the fourth entity node (940) and the fifth entity node (950) are connected to the third entity node (930) via a fourth edge (942) and a fifth edge (952), respectively. However, the structure of the graph, for example, the number of nodes and the connection relationship, is not limited thereto.

[0096] After the graph data illustrated on the left side of FIG. 9 is output (e.g., displayed), the user can make an input (e.g., touch, drag, gesture, etc.) to delete the fourth entity node (940). In this case, the information processing system can remove the fourth entity node (940) and the fourth edge (942) connected to the fourth entity node (940), as in the graph data illustrated on the right side of FIG. 9.

[0097] Then, the information processing system can restructure the graph data from which the fourth entity node (940) and the fourth edge (942) are removed. For example, the information processing system can restructure the graph data into a structure in which the graph data includes a data node (900), a first entity node (910), a second entity node (920), a third entity node (930), and a fifth entity node (950), and the first entity node (910), the second entity node (920), and the third entity node (930) are connected to the data node (900) via a first edge (912), a second edge (922), and a third edge (932), respectively, and the fifth entity node (950) is connected to the third entity node (930) via a fifth edge (952). In this way, the information processing system can generate graph data more suitable for the user's intent by restructuring graph data generated based on a natural language query based on user input, thereby supporting data retrieval suitable for the user's intent.

[0098] FIG. 10 is a diagram illustrating a search result provision method according to one embodiment of the present disclosure. Referring to FIG. 10, a processor (e.g., a processor (334) of FIGS. 3 to 5) of an information processing system (e.g., an information processing system (230) of FIGS. 2 and 3) may receive a natural language query (e.g., a natural language query (110) of FIG. 1) in step 1010 (S1010).

[0099] In step S1020, the processor may generate graph data (e.g., graph data (122) of FIG. 1). According to one embodiment, the processor may generate the graph data through a machine learning model (e.g., the machine learning model (120) of FIG. 1) based on the received natural language query. For example, the processor may generate a plurality of entities and relationships between the plurality of entities from the natural language query through the machine learning model, set each of the plurality of entities as an entity node, and set an edge, which is a main line between the entity nodes, using the relationships between the plurality of entities. According to one embodiment, the processor may generate a data node associated with the natural language query. For example, the processor may generate a data node for the natural language query itself, and set an edge representing a relationship between an entity node and an entity extracted from the natural language query.

[0100] In one embodiment, the processor may add, through a machine learning model, entities that are not included in the natural language query but are related to the natural language query to a plurality of entities extracted from the natural language query. For example, the processor may add, through the machine learning model, entities corresponding to at least one of a synonym, an analogue, or an expression indicating a context determined based on the natural language query to the plurality of entities associated with the natural language query. In one embodiment, the processor may change, through the machine learning model, an entity corresponding to a keyword extracted from the natural language query among the plurality of entities associated with the natural language query to an entity corresponding to a synonym of the keyword.

[0101] In one embodiment, the processor may output (e.g., display) the generated graph data. In one embodiment, after the graph data is output (e.g., displayed), the processor may receive user input for deleting, adding, or modifying at least one entity or relationship between entities associated with the graph data. In this case, the processor may restructure the graph data based on the received user input. For example, the processor may reconfigure entities and relationships between entities when at least one entity or relationship between entities included in the graph data has been deleted, added, or modified.

[0102] In step 1030 (S1030), the processor may obtain an embedding vector. According to one embodiment, the processor may obtain an embedding vector (e.g., the embedding vector (132) of FIG. 1) from generated graph data using a graph embedding algorithm (e.g., the graph embedding algorithm (130) of FIG. 1). For example, the processor may transform a high-dimensional graph structure into a low-dimensional embedding vector while preserving the similarity and structural information of nodes included in the graph data.

[0103] In step S1040, the processor may identify an index (e.g., the first index (142) of FIG. 1) in an index database (e.g., the index database (140) of FIG. 1). According to one embodiment, the processor may identify an index in the index database based on the acquired embedding vector. For example, the processor may identify an index by comparing an embedding vector acquired based on a natural language query (e.g., the first embedding vector) with an embedding vector stored in the index database (e.g., the second embedding vector). According to one embodiment, the processor may calculate a similarity between embedding vectors and identify an index corresponding to at least one second embedding vector having a high similarity (e.g., the second index (144) of FIG. 1).

[0104] At step 1050 (S1050), the processor may extract data from a source database (e.g., the source database (150) of FIG. 1). For example, the processor may extract data from the source database based on the identified index.

[0105] At step 1060 (S1060), the processor may provide search results for a natural language query. For example, the processor may provide search results for a natural language query based on the extracted data.

[0106] The above flowchart and description are merely examples, and some embodiments may implement the system differently. For example, in some embodiments, the order of each step may be changed, some steps may be repeated, some steps may be omitted, or some steps may be added.

[0107] The above-described method may be provided as a computer program stored on a computer-readable recording medium for execution on a computer. The medium may be one that continuously stores a computer-executable program or one that temporarily stores it for execution or download. In addition, the medium may be various recording means or storage means in the form of a single or multiple hardware combinations, and is not limited to a medium directly connected to a computer system, but may also be distributed over a network. Examples of the medium may include magnetic media such as hard disks, floppy disks, and magnetic tapes, optical recording media such as CD-ROMs and DVDs, magneto-optical media such as floptical disks, and those configured to store program instructions, including ROM, RAM, and flash memory. In addition, examples of other media may include recording or storage media managed by app stores that distribute applications, sites that supply or distribute various software, servers, etc.

[0108] The methods, operations, or techniques of the present disclosure may be implemented by various means. For example, these techniques may be implemented in hardware, firmware, software, or a combination thereof. Those skilled in the art will appreciate that the various exemplary logical blocks, modules, circuits, and algorithm steps described in connection with the disclosure herein may be implemented as electronic hardware, computer software, or combinations of both. To clearly illustrate this interchangeability of hardware and software, various exemplary components, blocks, modules, circuits, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as hardware or software will depend on the particular application and the design requirements imposed on the overall system. Those skilled in the art may implement the described functionality in various ways for each particular application, but such implementations should not be construed as departing from the scope of the present disclosure.

[0109] In a hardware implementation, the processing units used to perform the techniques may be implemented within one or more ASICs, DSPs, digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), processors, controllers, microcontrollers, microprocessors, electronic devices, other electronic units designed to perform the functions described herein, a computer, or a combination thereof.

[0110] Accordingly, the various exemplary logical blocks, modules, and circuits described in connection with the present disclosure may be implemented or performed by any combination of a general-purpose processor, a DSP, an ASIC, an FPGA or other programmable logic device, discrete gate or transistor logic, discrete hardware components, or those designed to perform the functions described herein. A general-purpose processor may be a microprocessor, but in the alternative, the processor may be any conventional processor, controller, microcontroller, or state machine. A processor may also be implemented as a combination of computing devices, e.g., a combination of a DSP and a microprocessor, a plurality of microprocessors, one or more microprocessors in conjunction with a DSP core, or any other such configuration.

[0111] In a firmware and / or software implementation, the techniques may be implemented as instructions stored on a computer-readable medium, such as random access memory (RAM), read-only memory (ROM), non-volatile random access memory (NVRAM), programmable read-only memory (PROM), erasable programmable read-only memory (EPROM), electrically erasable PROM (EEPROM), flash memory, a compact disc (CD), a magnetic or marking data storage device, etc. The instructions may be executable by one or more processors and may cause the processor(s) to perform certain aspects of the functionality described herein.

[0112] When implemented in software, the techniques described above may be stored on or transmitted as one or more instructions or code on a computer-readable medium. Computer-readable media includes both computer storage media and communication media, including any medium that facilitates transfer of a computer program from one place to another. Storage media may be any available media that can be accessed by a computer. By way of example, and not limitation, such computer-readable media can include RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer. Also, any connection is properly termed a computer-readable medium.

[0113] For example, if the software is transmitted from a website, server, or other remote source using coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, digital subscriber line, or wireless technologies such as infrared, radio, and microwave are included within the definition of media. Disk and disc, as used herein, includes compact discs, laser discs, optical discs, digital versatile discs (DVDs), floppy disks, and Blu-ray discs, where disks typically reproduce data magnetically, whereas discs reproduce data optically using lasers. Combinations of the above should also be included within the scope of computer-readable media.

[0114] A software module may reside in RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, a hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art. An exemplary storage medium may be coupled to the processor such that the processor can read information from, and write information to, the storage medium. Alternatively, the storage medium may be integral to the processor. The processor and the storage medium may reside in an ASIC. The ASIC may reside in a user terminal. Alternatively, the processor and the storage medium may reside as discrete components in the user terminal.

[0115] While the embodiments described above have been described as utilizing aspects of the presently disclosed subject matter in one or more standalone computer systems, the present disclosure is not limited thereto and may be implemented in conjunction with any computing environment, such as a network or distributed computing environment. Furthermore, aspects of the present disclosure may be implemented in multiple processing chips or devices, and storage may be similarly affected across multiple devices. Such devices may include personal computers, network servers, and portable devices.

[0116] While the present disclosure has been described in connection with certain embodiments herein, various modifications and variations may be made without departing from the scope of the present disclosure, as would be understood by those skilled in the art. Furthermore, such modifications and variations are intended to fall within the scope of the claims appended to this specification.

Claims

1. A method for providing search results, performed by at least one processor, Step of receiving a natural language query; A step of generating graph data through a machine learning model based on the above natural language query; A step of obtaining a first embedding vector from the generated graph data using a graph embedding algorithm; A step of identifying an index in an index database based on the first embedding vector obtained above; A step of extracting data from a source database based on the above identified index; and A step of providing search results for the natural language query based on the extracted data. A method of providing search results, including:

2. In paragraph 1, The above machine learning model is, A method for providing search results, wherein the method is trained to generate a plurality of entities related to the natural language query and relationships between the plurality of entities from the natural language query.

3. In paragraph 2, The above machine learning model is, A method for providing search results, wherein the method learns to add an entity corresponding to at least one of a synonym or similar word of a keyword extracted from the natural language query or an expression indicating a context determined based on the natural language query to the plurality of entities.

4. In paragraph 2, The above machine learning model is, A method for providing search results, wherein the method learns to change an entity corresponding to a keyword extracted from a natural language query among the plurality of entities into an entity corresponding to a synonym of the keyword.

5. In paragraph 1, Step for displaying the above graph data A method of providing search results, further comprising:

6. In paragraph 5, A step of receiving user input for deleting, adding, or changing at least one of an entity or a relationship between entities associated with said graph data; and A step of restructuring the graph data based on the received user input. A method of providing search results, further comprising:

7. In paragraph 1, The above index database is, A method for providing search results, comprising: having a graph data structure; and including a second embedding vector obtained using a graph embedding algorithm for each node of graph data included in the index database as an index.

8. In paragraph 7, The step of identifying the above index is: A step of calculating the similarity between the first embedding vector and the second embedding vector; and A step of identifying the index in the index database based on the similarity calculated above. A method of providing search results, including:

9. A computer-readable non-transitory recording medium storing one or more computer programs including commands for performing a method according to any one of claims 1 to 8.

10. In the system, memory; and At least one processor coupled to said memory and configured to execute at least one computer-readable program contained in said memory, At least one of the above programs, Receive natural language queries, Based on the above natural language query, graph data is generated through a machine learning model, Using the graph embedding algorithm, an embedding vector is obtained from the generated graph data, Based on the obtained embedding vector, an index is identified in the index database, Based on the above identified index, data is extracted from the source database, A system comprising commands for providing search results for the natural language query based on the extracted data.

Images