CROSS-REFERENCE TO RELATED APPLICATIONS AND PRIORITY
[001] The present application does not claim priority from any patent application.

TECHNICAL FIELD
[002] The present disclosure in general relates to the field of mapping category for a query. More particularly, the present invention relates to a system and method for mapping a category associated with a query.
BACKGROUND
[003] Currently, due to an introduction of an Artificial Intelligence (AI) using Machine Learning, enterprises are moving towards automated conversational chat based bots that have capabilities to answer the queries of a customer. It is to be noted that the AI based Chat bots have Natural Language Processing (NLP) capabilities that may help in detecting an intent of the queries. However, the intent detection by the AI based Chat bots may be limited for various input variations that were configured by a developer during the bot building phase. In other words, the aforementioned approach for detecting the intent is limited to possible intent combinations and appropriate responses as the developer cannot think of all possible inputs from the customer during the building of the AI based Chat bots.
SUMMARY
[004] Before the present systems and methods for mapping a category associated with a failed query, is described, it is to be understood that this application is not limited to the particular systems, and methodologies described, as there can be multiple possible embodiments which are not expressly illustrated in the present disclosure. It is also to be understood that the terminology used in the description is for the purpose of describing the particular versions or embodiments only, and is not intended to limit the scope of the present application. This summary is provided to introduce concepts related to systems and method for mapping the category associated with the failed query. This summary is not intended to identify essential features of the claimed subject matter nor is it intended for use in determining or limiting the scope of the claimed subject matter.
[005] In one implementation, a system for mapping a category associated with a failed query is illustrated. The system comprises a memory and a processor coupled to the memory, further the processor is configured to detect a failed query comprising a user ID and a primary Representational State Transfer-Application Programming Interface (REST-API) called to execute the failed query. Further, the processor may detect a successful query executed within a predefined time. The successful query may comprise the user ID, a successful query result, and a secondary REST-API called to execute the successful query. Furthermore, the processor may map a category associated with the failed query when the primary REST-API and the secondary REST-API are same.
[006] In another implementation, a method for mapping a category associated with a failed query is illustrated. In one embodiment, the method may comprise detecting a failed query comprising a user ID and a primary Representational State Transfer-Application Programming Interface (REST-API) called to execute the failed query. Further, the method may comprise detecting a successful query executed within a predefined time. The successful query may comprise the user ID, a successful query result, and a secondary REST-API called to execute the successful query. Furthermore, the method may comprise mapping a category associated with the failed query when the primary REST-API and the secondary REST-API are same.
[007] In yet another implementation, a computer program product having embodied computer program for mapping a category associated with a failed query is disclosed. In one embodiment, the program may comprise detecting a failed query comprising a user ID and a primary Representational State Transfer-Application Programming Interface (REST-API) called to execute the failed query. Further, the program may comprise detecting a successful query executed within a predefined time. The successful query may comprise the user ID, a successful query result, and a secondary REST-API called to execute the successful query. Furthermore, the program may comprise mapping a category associated with the failed query when the primary REST-API and the secondary REST-API are same.
BRIEF DESCRIPTION OF DRAWINGS
[008] The detailed description is described with reference to the accompanying figures. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The same numbers are used throughout the drawings to refer like features and components.
[009] Figure 1 illustrates a network implementation of a system for mapping a category associated with a failed query, in accordance with an embodiment of the present subject matter.
[0010] Figure 2 illustrates the system for mapping the category associated with the failed query, in accordance with an embodiment of the present subject matter.
[0011] Figure 3 illustrates a method for mapping a category associated with the failed query, in accordance with an embodiment of the present subject matter.
DETAILED DESCRIPTION
[0012] Some embodiments of the present disclosure, illustrating all its features, will now be discussed in detail. The words “detecting”, “identifying”, “collecting”, “mapping” and other forms thereof, are intended to be equivalent in meaning and be open ended in that an item or items following any one of these words is not meant to be an exhaustive listing of such item or items, or meant to be limited to only the listed item or items. It must also be noted that as used herein and in the appended claims, the singular forms "a", "an" and "the" include plural references unless the context clearly dictates otherwise. Although any systems and methods similar or equivalent to those described herein can be used in the practice or testing of embodiments of the present disclosure, the exemplary, systems and methods for mapping a category associated with a failed query are now described. The disclosed embodiments of the system and method for mapping the category associated with the failed query are merely exemplary of the disclosure, which may be embodied in various forms.
[0013] Various modifications to the embodiment will be readily apparent to those skilled in the art and the generic principles herein may be applied to other embodiments. However, one of ordinary skill in the art will readily recognize that the present disclosure for mapping a category associated with a failed query is not intended to be limited to the embodiments illustrated, but is to be accorded the widest scope consistent with the principles and features described herein.
[0014] The present subject matter relates to mapping a category associated with a failed query. In one embodiment, a failed query may be detected. The failed query may comprise a user ID and a primary representational State Transfer-Application Programming Interface (REST-API) called to execute the failed query. Further, a successful query may be detected within a predefined time. The successful query may comprise the user ID, a successful query result, and a secondary REST-API called to execute the successful query. Once the successful query is detected, a category associated with the failed query may be mapped when the primary REST-API and the secondary REST-API are same.
[0015] Referring now to Figure 1, a network implementation 100 of a system 102 for mapping a category associated with a failed query is disclosed. Although the present subject matter is explained considering that the system 102 is implemented on a server, it may be understood that the system 102 may also be implemented in a variety of computing systems, such as a laptop computer, a desktop computer, a notebook, a workstation, a mainframe computer, a server, a network server, and the like. In one implementation, the system 102 may be implemented over a cloud network. Further, it will be understood that the system 102 may be accessed by multiple users through one or more user devices 104-1, 104-2…104-N, collectively referred to as user device 104 hereinafter, or applications residing on the user device 104. Examples of the user device 104 may include, but are not limited to, a portable computer, a personal digital assistant, a handheld device, and a workstation. The user device 104 may be communicatively coupled to the system 102 through a network 106.
[0016] In one implementation, the network 106 may be a wireless network, a wired network or a combination thereof. The network 106 may be implemented as one of the different types of networks, such as intranet, local area network (LAN), wide area network (WAN), the internet, and the like. The network 106 may either be a dedicated network or a shared network. The shared network represents an association of the different types of networks that use a variety of protocols, for example, Hypertext Transfer Protocol (HTTP), Transmission Control Protocol/Internet Protocol (TCP/IP), Wireless Application Protocol (WAP), and the like, to communicate with one another. Further, the network 106 may include a variety of network devices, including routers, bridges, servers, computing devices, storage devices, and the like.
[0017] Further, the system 102 may be connected to a Natural Language interface (NLI) 110. The connection between the system 102 and the NLI 110 may be a wireless connection or a wired connection. Examples of the NLI 110 may include, but not limited to, a chatbot, a conversational interface and the like. Furthermore, the system 102 may be connected to a Web User Interface 112. The connection between the system 102 and the Web User Interface 112 may be a wired connection or a wireless connection.
[0018] In one embodiment, the system 102 may detect a failed query. The failed query may be detected in the NLI 110. The failed query may comprise failed query data. The failed query data may be stored in a repository. The failed query data may comprise a user ID, a primary Representational State Transfer-Application Programming Interface (REST-API) called to execute the failed query, a primary Application Programming Interface (API) gateway and the like.
[0019] Further, the system 102 may detect a successful query. The successful query may be executed by the Web User Interface 112 within a predefined time. The successful query may comprise successful query data. The successful query data may comprise the user ID, a successful query result, a secondary REST-API called to execute the successful query, a secondary Application Programming Interface (API) and the like. The successful query data may be stored in the repository.
[0020] Once the successful query is detected, the system 102 may map a category associated with the failed query, when the primary REST-API and the secondary REST-API are same. The category may be mapped based on an analysis of the successful query result. The category may be one of requesting, questioning, recommending, commanding, searching and the like. In one aspect, the category may correspond to an intent of the user behind the failed query. In other words, the system 102 may map the intent associated with failed query.
[0021] Referring now to figure 2, the system 102 for mapping a category associated with a query is illustrated in accordance with an embodiment of the present subject matter. In one embodiment, the system 102 may include at least one processor 202, an input/output (I/O) interface 204, and a memory 206. The at least one processor 202 may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, state machines, logic circuitries, and/or any devices that manipulate signals based on operational instructions. Among other capabilities, at least one processor 202 may be configured to fetch and execute computer-readable instructions stored in the memory 206.
[0022] The I/O interface 204 may include a variety of software and hardware interfaces, for example, a web interface, a graphical user interface, and the like. The I/O interface 204 may allow the system 102 to interact with the user directly or through the user device 104. Further, the I/O interface 204 may enable the system 102 to communicate with other computing devices, such as web servers and external data servers (not shown). The I/O interface 204 may facilitate multiple communications within a wide variety of networks and protocol types, including wired networks, for example, LAN, cable, etc., and wireless networks, such as WLAN, cellular, or satellite. The I/O interface 204 may include one or more ports for connecting a number of devices to one another or to another server.
[0023] The memory 206 may include any computer-readable medium known in the art including, for example, volatile memory, such as static random access memory (SRAM) and dynamic random access memory (DRAM), and/or non-volatile memory, such as read only memory (ROM), erasable programmable ROM, flash memories, hard disks, optical disks, and magnetic tapes. The memory 206 may include modules 208 and data 210.
[0024] The modules 208 may include routines, programs, objects, components, data structures, and the like, which perform particular tasks, functions or implement particular abstract data types. In one implementation, the module 208 may include a failed query detection module 212, a successful query detection module 214, a mapping module 216, and other modules 218. The other modules 218 may include programs or coded instructions that supplement applications and functions of the system 102.
[0025] The data 210, amongst other things, serve as a repository for storing data processed, received, and generated by one or more of the modules 208. The data 210 may also include a repository 220, and other data 222. In one embodiment, the other data 222 may include data generated as a result of the execution of one or more modules in the other modules 218.
[0026] In one implementation, a user may access the system 102 via the I/O interface 204. The user may be registered using the I/O interface 204 in order to use the system 102. In one aspect, the user may access the I/O interface 204 of the system 102 for obtaining information, providing input information or configuring the system 102.
[0027] In one embodiment, the failed query detection module 212 may detect a failed query. The failed query may be detected in the NLI platform 110. The failed query may comprise a user ID, a primary Application Programming Interface (API) gateway, a primary Representational State Transfer-Application Programming Interface (REST-API) called to execute the failed query and the like. In one aspect, the failed query may be received based on inputs of the user associated with the user ID. The primary API gateway may ensure an access control. The primary REST-API may execute the failed query. In other words, the REST-API failed to execute the failed query.
[0028] In one exemplary embodiment, the NLI platform 110 may receive a query from the user. The NLI platform 110 may process the query via the primary API gateway and the primary REST-API. In this case, the primary API gateway may validate the authentication for the user ID. If the user ID is valid, then the primary API gateway may allow the access to the user. Further, the REST-API may execute the query. In one aspect, the REST-API fails to execute the query. In this case, the failed query detection module 212 may detect the failed query in the NLI platform 110.
[0029] Further, the successful query detection module 214 may detect a successful query. The successful query may be executed by the Web User Interface platform 212. The successful query may be executed within a predefined time from the detection of the failed query. The successful query may comprise the user ID, a successful query result, a secondary Application Programming Interface (API) gateway, a secondary Representational State Transfer-Application Programming Interface (REST-API) called to execute the successful query, and the like. The secondary API gateway may ensure an access control. The secondary REST-API may execute the successful query. In other words, the REST-API may execute the successful query and generate the successful query result. It is to be noted that the successful query may be executed for the same user ID for whom the failed query was executed. Once the successful query is detected, the successful query may be stored in the repository 220.
[0030] Upon detection of the successful query, the mapping module 216 may compare the primary REST-API and the secondary REST-API. Further, the mapping module 216 may map a category associated with the failed query, when the primary REST-API and the secondary REST-API are same. The category may be mapped based on an analysis of the successful query result. In one embodiment, the mapping module 216 may determine the category of the failed query based on analysis of the successful query result. The category may correspond to an intent of the user to execute the failed query. The category may be referred as the intent. Examples of the category may include, but not limited to, requesting, recommending, commanding, searching, questioning and the like.
[0031] Once the category associated with the failed query is mapped, the mapping module 216 may store the failed query and the category in the NLI platform 110. In one embodiment, the failed query and the category may be stored in a database of the NLI platform 110. The NLI platform 110 may be trained to execute the failed query by mapping the category for the failed query. In one embodiment, the NLI platform 110 may receive a feedback from the user. The feedback may be received for each query executed by the NLI platform 110.
[0032] In one exemplary embodiment, construe “How much can I withdraw today?” as a query received from the user. In this case, the mapping module 216 may map the category “Banking” for the query.
[0033] In another exemplary embodiment, construe “Can you please order Masala Dosa?” as a query received from the user. In this case, the mapping module 216 may map “Ordering Food” as the category for the query.
[0034] Further, the mapping module 216 may analyse a set of words from the failed query. In one embodiment, the failed query may be tokenized to split the failed query into the set of words. Once the set of words are analysed, the mapping module 216 may extract a subset of words from the set of words. The subset of words may be passed through the primary REST-API. The mapping module 216 may analyse the subset of words. Based on the analysis of the subset of words, the mapping module 216 may identify a sub-category associated with the query. The sub-category may correspond to an entity associated with the failed query.
[0035] Once the entity is identified, the mapping module 216 may generate a formatted query associated with the failed query. The formatted query may be further stored in the NLI platform 110. In one embodiment, the formatted query associated with the failed query may be stored in the database of the NLI platform 110. Further, the NLI platform may use a machine learning algorithm to learn the category and the subcategory of the failed query in future.
[0036] Exemplary embodiments discussed above may provide certain advantages. Though not required to practice aspects of the disclosure, these advantages may include those provided by the following features.
[0037] Some embodiments of the system and the method is configured to improve efficiency of a Natural Language Interface platform.
[0038] Some embodiments of the system and the method is configured to enable self-learning of the Natural Language Interface platform.
[0039] Referring now to figure 3, a method 300 for mapping a category associated with a failed query, is disclosed in accordance with an embodiment of the present subject matter. The method 300 may be described in the general context of computer executable instructions. Generally, computer executable instructions can include routines, programs, objects, components, data structures, procedures, modules, functions, and the like, that perform particular functions or implement particular abstract data types. The method 300 may also be practiced in a distributed computing environment where functions are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, computer executable instructions may be located in both local and remote computer storage media, including memory storage devices.
[0040] The order in which the method 300 is described is not intended to be construed as a limitation, and any number of the described method blocks can be combined in any order to implement the method 300 or alternate methods. Additionally, individual blocks may be deleted from the method 300 without departing from the spirit and scope of the subject matter described herein. Furthermore, the method 300 can be implemented in any suitable hardware, software, firmware, or combination thereof. However, for ease of explanation, in the embodiments described below, the method 300 may be considered to be implemented in the above described system 102.
[0041] At block 302, a failed query may be detected. In one implementation, the failed query detection module 212 may detect the failed query. The failed query may comprise a user ID, a primary Application Programing Interface (API) gateway, a primary REST-API called to execute the failed query and the like. The failed query may be detected in a Natural Language Interface (NLI) platform.
[0042] At block 304, a successful query may be detected. In one implementation, the successful query detection module 214 may detect the successful query. The successful query may be executed by a Web User Interface within a predefined time. The successful query may comprise the user ID, a successful query result, a secondary API gateway, a secondary REST-API called to execute the successful query.
[0043] At block 306, a category associated with the failed query may be mapped. In one implementation, the mapping module 216 may map the category associated with the failed query. The category may be mapped based on an analysis of the successful query result. The category may be mapped, when the primary REST-API and the secondary REST-API are same.
[0044] In one exemplary embodiment, the system 102 may have finite intents and finite actions which are mapped to respective Rest APIs(c). It is to be noted that same Rest APIs(c) is used by a Natural Language Interface platform and a Web User Interface platform for doing same actions. In one example, construe an intent which fetches a weather forecast for a given city. The intent training may look like something as shown below:
[0045] How is the weather in ?
Will it rain in ?
What is the weather looks like in ?
What is the current temperature in ?
How does the forecasted weather look today?
Do I need to take an umbrella today?
[0046] It is to be noted that the words listed within “<>” may be the city which a Named Entity Recognition (NER) engine will use for recognizing the city.
[0047] Further, the action may be in a format as shown below:
[0048] Call Rest API – https://somedomain/weatherapi?city=
Sample Response:
{
“condition”: “Forecasted weather for is ”,
“current_temperature”: “24.5 C”,
“min_temperature”: “24 C”,
“max_temperature: “25 C”,
“humidity”: “65%”,
“rain”:”80%”
}
[0049] Further, the NLI platform may receive queries N1 and N2 from the user. The query N1 may be “Will it snow today in Dubai?”, and the query N2 may be “What are the chances of thunder storm in Chicago”. Further, construe that the NLI platform failed to execute the queries N1 and N2. It may be because the intent(d) stored in the NLI platform doesn’t contains the above mentioned negative scenarios or anything close to these scenarios. Further, the user may try to get the information (N1, N2) from the Web User Interface platform, which is also pointing to the same Rest API(c) to get the weather forecast.
[0050] The system 102 may capture data associated with the N1, N2 from the NLI platform. Further, the system 102 may capture data associated with the N1, N2 from the Web User Interface Platform. Further, the system 102 may tokenize N1, N2. Based on the tokenization, the system 102 may check the cities passed through Rest API(c) to extract the cities (c1 = Dubai, c2 = Chicago). The system 102 may further map the N1, N2 to intent(a) and will append the N1, N2 to the training(b) by capturing the cities. Thus, the system 102 may add the new records for the intent(a). The new records may be “Will it snow today in ” and “What are the chances of thunder storm in ”.
[0051] It is to be noted that from next time onwards any new variants of the N1, N2 may be handled efficiently by the NLI platform. Also, the NLI platform may run the action(e) against the queries along with other trained queries.
[0052] In another exemplary embodiment, the system 102 may store a training set for an intent “Leave Application L1”. The intent training set may look like something as shown below:
[0053] Training set – Leave application (L1):
Apply for tomorrow
I want to take
Can you help me apply for a ?
Apply a for today
[0054] In one aspect, the intent L1 may be mapped to perform an action (A1) using the Rest API – “https://somedomain/applyleave?user=&leavetype=”. In this case, response for the intent L1 may be Sample Response of L1: {“Success”}.

[0055] It is to be noted that the NLI platform may be able to identify the intent and perform action for the above training set. This is because the training set comprises a positive query. Further, the NLI platform may call the Rest API (A1) to complete the leave application: a) I want to apply for an Annual Leave, b) I am sick and can you help me apply a Sick leave for today
[0056] Further, the NLI platform may receive the queries F1 and F2. The query F1 may be “I want to take an off”, and the query F2 may be “I am not feeling well and want to take an off. Can you help?”. In one aspect, the queries F1 and F2 may be negative scenarios. In this case, the NLI platform may will fail to identify the intent (L1) as the NLI platform is not trained to handle these kind of queries.
[0057] In one embodiment, construe the user using the Web User Interface platform to apply for leave. In this case, the REST-API used by the NLI platform and the Web User Interface platform may be same. The Web User Interface platform may successfully execute the query and apply for the leave. Further, the system 102 may map the queries F1 and F2 to the training set of L1. The system 102 may enable the NLI platform to learn from the queries F1 and F2 to answer these unknown phases for future use.
[0058] Although implementations for systems and methods for mapping a category associated with a query have been described, it is to be understood that the appended claims are not necessarily limited to the specific features or methods described. Rather, the specific features and methods are disclosed as examples of implementations for mapping the category associated with the query.

Claims:
1. A system for mapping a category associated with a failed query, the system comprises:
a memory;
a processor coupled to the memory, wherein the processor is configured to:
detect a failed query comprising a user ID and a primary Representational State Transfer-Application Programming Interface (REST-API) called to execute the failed query;
detect a successful query executed within a predefined time, wherein the successful query comprises the user ID, a successful query result, and a secondary REST-API called to execute the successful query; and
map a category associated with the failed query when the primary REST-API and the secondary REST-API are same.

2. The system as claimed in claim 1, wherein the failed query is detected in a Natural Language Interface (NLI) platform.

3. The system as claimed in claim 1, wherein the successful query is executed by a Web User Interface platform.

4. The system as claimed in claim 1, wherein the category is mapped based on an analysis of the successful query result.

5. The system as claimed in claim 1, wherein the category is one of requesting, questioning, commanding, and searching.

6. The system as claimed in claim 1, further configured to:
analyse a set of words from the failed query;
extract a subset of words from the set of words, wherein the subset of words is passed through the primary REST-API; and
identify a sub-category associated with the failed query, wherein the sub-category is identified based on an analysis of the subset of words.

7. The system as claimed in claim 1, further configured to receive a feedback for a set of queries, wherein the feedback is received from a user via the Natural Language Interface (NLI) platform.

8. A method for mapping a category associated with a failed query, the method comprises:
detecting, by a processor, a failed query, wherein the failed query comprises a user ID and a primary Representational State Transfer-Application Programming Interface (REST-API) called to execute the failed query;
detecting, by the processor, a successful query executed within a predefined time, wherein the successful query comprises the user ID, a successful query result, and a secondary REST-API called to execute the successful query; and
mapping, by the processor, a category associated with the failed query when the primary REST-API and the secondary REST-API are same.

9. The method as claimed in claim 8, wherein the failed query is detected in a Natural Language Interface (NLI) platform.

10. The method as claimed in claim 8, wherein the successful query is executed by a Web User Interface platform.

11. The method as claimed in claim 8, wherein the category is mapped based on an analysis of the successful query result.

12. The system as claimed in claim 8, wherein the category is one of requesting, questioning, commanding, and searching.

13. The method as claimed in claim 8, further comprises
analysing a set of words from the failed query;
extracting a subset of words from the set of words, wherein the subset of words is passed through the primary REST-API; and
identifying a sub-category associated with the failed query, wherein the sub-category is identified based on an analysis of the subset of words.

14. The method as claimed in claim 8, further comprises receiving a feedback for a set of queries, wherein the feedback is received from a user via the Natural Language Interface (NLI) platform.

15. A computer program product having embodied thereon a computer program for mapping a category associated with a failed query, the computer program product comprises:
detecting a failed query, wherein the failed query comprises a user ID and a primary Representational State Transfer-Application Programming Interface (REST-API) called to execute the failed query;
detecting a successful query executed within a predefined time, wherein the successful query comprises the user ID, a successful query result, and a secondary REST-API called to execute the successful query; and
mapping a category associated with the failed query when the primary REST-API and the secondary REST-API are same.