EP2849084A1 - System and method for generating a plan to complete a task in computing environment - Google Patents
System and method for generating a plan to complete a task in computing environment Download PDFInfo
- Publication number
- EP2849084A1 EP2849084A1 EP14183793.0A EP14183793A EP2849084A1 EP 2849084 A1 EP2849084 A1 EP 2849084A1 EP 14183793 A EP14183793 A EP 14183793A EP 2849084 A1 EP2849084 A1 EP 2849084A1
- Authority
- EP
- European Patent Office
- Prior art keywords
- task
- atoms
- database
- precondition
- logical
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Withdrawn
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/48—Program initiating; Program switching, e.g. by interrupt
- G06F9/4806—Task transfer initiation or dispatching
- G06F9/4843—Task transfer initiation or dispatching by program, e.g. task dispatcher, supervisor, operating system
- G06F9/4881—Scheduling strategies for dispatcher, e.g. round robin, multi-level priority queues
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N5/00—Computing arrangements using knowledge-based models
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06N—COMPUTING ARRANGEMENTS BASED ON SPECIFIC COMPUTATIONAL MODELS
- G06N5/00—Computing arrangements using knowledge-based models
- G06N5/02—Knowledge representation; Symbolic representation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06Q—INFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
- G06Q10/00—Administration; Management
- G06Q10/06—Resources, workflows, human or project management; Enterprise or organisation planning; Enterprise or organisation modelling
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06Q—INFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
- G06Q10/00—Administration; Management
- G06Q10/06—Resources, workflows, human or project management; Enterprise or organisation planning; Enterprise or organisation modelling
- G06Q10/063—Operations research, analysis or management
- G06Q10/0631—Resource planning, allocation, distributing or scheduling for enterprises or organisations
Definitions
- the present subject matter described herein in general, relates to intelligent systems for planning, and more particularly to planning systems for generating a plan in a computing environment.
- planning is a process of selecting and organizing actions by considering expected outcomes or goals.
- plan state denotes a state of the world and is represented as a set of state facts.
- plan state undergoes changes as determined by post conditions of actions included in a plan.
- the planning system has to select and execute a set of actions in order to reach a goal state.
- conventional planning techniques do not provide optimized use of data during generation of the plan.
- the conventional planning techniques use the monolithic predicate based schema for the plan state representation, wherein a world state is described as a set of predicates that are currently true.
- the world state has to be obtained by aggregating information from different modular sources represented through multiple knowledge representation techniques. Further performance of the planning system may be affected when size of the plan state is enormously large.
- the conventional planning techniques face many challenges in providing efficient and optimized plan state representation during plan generation.
- the plan state may be enormously large which in turn may affect performance of the planning system.
- the HTN (Hierarchical Task Network) planner JSHOP2 (a Java implementation of Simple Hierarchical Ordered Planner) suffers from scalability problem for the plan state having large number of state facts represented in a monolithic predicate-based schema.
- the state facts comprise frequently varying data and static data.
- the frequently varying data and the static data, both represented in the monolithic predicate-based schema resides continuously in the memory of the planning system. This results in over utilization of memory.
- data sources follow modularity approach.
- data comprising weather information, road information and transport information may be maintained in database systems.
- Further separate tables may be used to store the data. Therefore a change in one module or a table does not affect the change in other modules or tables of the database systems.
- the current plan state representation does not follow the modularity approach as the information in the plan state is presented using the monolithic predicate-based schema.
- a method for generating a plan to complete a task in a computing environment comprises representing a plan state comprising a first dataset and a second dataset.
- the first dataset and the second dataset are associated with a task.
- the second dataset is received from one or more heterogeneous data sources.
- the first dataset comprises logical atoms represented in a predicate-based schema.
- the second dataset comprises database atoms represented in a non-predicate based schema.
- the logical atoms indicate a dynamically varying data to be accessed frequently.
- the database atoms indicate a static data.
- a database atom of the database atoms is represented with a path. The path facilitates selective access of the database atoms from the one or more heterogeneous data sources.
- the method further comprises iteratively selecting task methods from a set of predefined task methods and task operators from a set of predefined task operators, by matching with a task to be completed.
- the method further comprises successively executing the task methods and the task operators, as selected, in order to complete the task.
- the execution of a task method of the task methods and a task operator of the task operators include validating a first precondition associated with the task method and a second precondition associated with the task operator, by matching a first set of variables associated with the task method and a second set of variables associated with the task operator, with at least one of the logical atoms and the database atoms.
- the matching of the database atoms is facilitated using the path.
- the execution of the task method and the task operator further include assigning the first set of variables with a first set of values when the first precondition is valid and the second set of variables with a second set of values when the second precondition is valid.
- the first set of values and the second set of values are obtained from one or more logical atoms of the logical atoms and one or more database atoms of the database atoms, so matched with the first set of variables and the second set of variables respectively.
- the execution of the task method and the task operator further include executing the task method using the first set of values and executing the task operator using the second set of values.
- the method further comprises generating the plan based upon the execution of the task methods and the task operators.
- the representation of the database atoms in the non-predicate based schema and the selective access of the database atoms from the one or more heterogeneous data sources using the path makes the plan state scalable, practical and modular.
- Cache memory is used to store the database atoms so fetched.
- the logical atoms indicating dynamically varying data continually resides in the memory during the generation of the plan, whereas the database atoms indicating the static data is selectively loaded in the memory only when required during the generation of the plan, thereby facilitating optimal utilization of the memory and reducing data retrieval overhead during the generation of the plan.
- the one or more heterogeneous data sources comprise databases, ontologies, application program interface calls, and web services.
- a system for generating a plan to complete a task in a computing environment comprises a processor and a memory coupled to the processor.
- the processor is capable of executing programmed instructions stored in the memory.
- the programmed instructions are executed for representing a plan state comprising a first dataset and a second dataset, associated with a task.
- the second dataset is received from one or more heterogeneous data sources.
- the first dataset comprises logical atoms represented in a predicate-based schema.
- the second dataset comprises database atoms represented in a non-predicate based schema.
- the logical atoms indicate a dynamically varying data to be accessed frequently.
- the database atoms indicate a static data.
- a database atom of the database atoms is represented with a path.
- the path facilitates selective access of the database atoms from the one or more heterogeneous data sources.
- the programmed instructions are further executed for iteratively selecting task methods from a set of predefined task methods and task operators from a set of predefined task operators, by matching with a task to be completed.
- the programmed instructions are further executed for successively executing the task methods and the task operators, as selected, in order to complete the task.
- the execution of a task method of the task methods and a task operator of the task operators include validating a first precondition associated with the task method and a second precondition associated with the task operator, by matching a first set of variables associated with the task method and a second set of variables associated with the task operator, with at least one of the logical atoms and the database atoms.
- the matching of the database atoms is facilitated using the path.
- the execution of the task method and the task operator further include assigning the first set of variables with a first set of values when the first precondition is valid and the second set of variables with a second set of values when the second precondition is valid.
- the first set of values and the second set of values are obtained from one or more logical atoms of the logical atoms and one or more database atoms of the database atoms, so matched with the first set of variables and the second set of variables respectively.
- the execution of the task method and the task operator further include executing the task method using the first set of values and executing the task operator using the second set of values.
- the programmed instructions are further executed for generating the plan based upon the execution of the task methods and the task operators.
- a non-transitory computer readable medium embodying a program executable in a computing device for generating a plan to complete a task in a computing environment comprises a program code for representing a plan state comprising a first dataset and a second dataset, associated with a task.
- the second dataset is received from one or more heterogeneous data sources.
- the first dataset comprises logical atoms represented in a predicate-based schema.
- the second dataset comprises database atoms represented in a non-predicate based schema.
- the logical atoms indicate a dynamically varying data to be accessed frequently.
- the database atoms indicate a static data.
- a database atom of the database atoms is represented with a path, wherein the path facilitates selective access of the database atoms from the one or more heterogeneous data sources.
- the program further comprises a program code for iteratively selecting task methods from a set of predefined task methods and task operators from a set of predefined task operators, by matching with a task to be completed.
- the program further comprises a program code for successively executing the task methods and the task operators, as selected, in order to complete the task.
- the execution of a task method of the task methods and a task operator of the task operators include validating a first precondition associated with the task method and a second precondition associated with the task operator, by matching a first set of variables associated with the task method and a second set of variables associated with the task operator, with at least one of the logical atoms and the database atoms, and wherein the matching of the database atoms is facilitated using the path.
- the execution of the task method and the task operator further include assigning the first set of variables with a first set of values when the first precondition is valid and the second set of variables with a second set of values when the second precondition is valid.
- the first set of values and the second set of values are obtained from one or more logical atoms of the logical atoms and one or more database atoms of the database atoms, so matched with the first set of variables and the second set of variables respectively.
- the execution of the task method and the task operator further include executing the task method using the first set of values and executing the task operator using the second set of values.
- the program further comprises a program code for generating the plan based upon the execution of the task methods and the task operators.
- the system provides a framework that facilitates use of heterogeneous data sources to represent a plan state in order to generate the plan.
- the system and method facilitates representation of the plan state.
- the plan state representation comprises combination of information in predicate form as well as references to information in non-predicate form stored in a variety of data sources like databases, ontologies etc.
- the plan state representation using information from distributed heterogeneous data sources, without altering planning algorithm in concern is disclosed.
- the system provides a framework capable of handling the non-predicate based data along with the predicate based data and a provision to access the non-predicate based data from the plan state on demand basis.
- Key aspect of the present disclosure is to handle overheads caused by the non-predicate based data without changing main planning process.
- the system and method for generating the plan may comprise receiving one or more logical atoms, and one or more database atoms.
- the one or more logical atoms may be represented in a first schema
- the one or more database atoms may be represented in a second schema.
- the first schema may be predicate based schema.
- the logical atoms may be represented using predicate logic.
- the second schema may be non-predicate based schema and representation of the database atom comprises a path to selectively access the database atom stored in one or more data sources.
- the system and method may further receive a task list in a form of task network, set of task methods and set of task operators required to complete the task.
- the task list defines a task.
- the system and method select and execute a task method and/or a task operator iteratively from the set of task methods and the set of task operators to complete the task.
- the execution of the task method and the task operator may comprise iteratively verifying precondition associated with the task method and the task operator for validity.
- Precondition may be a logical expression of variables mentioned in a task method representation and a task operator representation.
- the precondition may be verified by comparing variables of the task method or the task operator with the logical atoms or the database atoms in order to match the variables with the logical atoms or the database atoms.
- the variables are assigned with the values obtained from the logical atoms and/or the database atoms so matched with the variables.
- the task method is selected, the task method is decomposed into sub-tasks, and the values of the arguments/variables of the task method is assigned to the arguments of the subtasks, and the sub-tasks are added to the task list in order to execute the subtasks.
- the subtasks may be executed by iteratively performing the selection and the execution of each subtask. Further, the system may generate the plan based upon the execution of all the tasks and sub-tasks form the task list.
- the system 102 may select a task method from the set of task methods and/or a task operator from the set of task operators and may execute the task method and/or the task operator.
- the system 102 may verify whether a precondition associated with the task method and/or the task operator is valid. After verifying the precondition, one or more variables of the precondition may be assigned with one or more values when the precondition is valid.
- the system may decompose the task method into one or more sub-tasks and may iteratively execute the one or more sub-tasks in order to complete the task.
- the system may generate the plan based on the execution of the task and each of the sub-tasks from the task list.
- 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.
- system 102 may be implemented in a cloud-based environment. 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 devices 104 hereinafter, or applications residing on the user devices 104. Examples of the user devices 104 may include, but are not limited to, a portable computer, a personal digital assistant, a handheld device, and a workstation.
- the user devices 104 are communicatively coupled to the system 102 through a network 106.
- the network 106 may be a wireless network, a wired network or a combination thereof.
- the network 106 can 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.
- the network 106 may include a variety of network devices, including routers, bridges, servers, computing devices, storage devices, and the like.
- 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.
- the at least one processor 202 is configured to fetch and execute computer-readable instructions stored in the memory 206.
- 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 a user directly or through the client devices 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 can 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.
- 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.
- volatile memory such as static random access memory (SRAM) and dynamic random access memory (DRAM)
- non-volatile memory such as read only memory (ROM), erasable programmable ROM, flash memories, hard disks, optical disks, and magnetic tapes.
- ROM read only memory
- erasable programmable ROM erasable programmable ROM
- the modules 208 include routines, programs, objects, components, data structures, etc., which perform particular tasks, functions or implement particular abstract data types.
- the modules 208 may include a receiving module 212, a planning module 214, an adaptation 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.
- the programs include programmed instructions.
- the data 210 serves 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 system database 222, and other data 224.
- the other data 224 may include data generated as a result of the execution of one or more modules in the other module 218.
- a user may use the client device 104 to access the system 102 via the I/O interface 204.
- the user may register using the I/O interface 204 in order to access the system 102.
- the working of the system 102 may be explained in detail by referring to details of Figures 2 and 3 .
- the system 102 may be used to generate a plan.
- the system 102 may be used to generate the plan to complete a task in a computing environment.
- the system 102 at first, receives data. Specifically, in the present implementation, the system receives data through the receiving module 212.
- the receiving module 212 may receive a problem definition.
- the problem definition may comprise a first dataset and a second dataset.
- the first dataset and the second dataset may be associated with the task.
- the task may be booking a ticket, moving packages between locations by trucks under certain spatial constraints and delivering deadlines, finding a sequence of biochemical (pathways) reactions in an organism producing certain substances, traveling and buying goods at selected markets minimizing costs and the like.
- the first dataset may be generated and the second dataset may be received from one or more data sources.
- the first dataset may comprise one or more logical atoms.
- the second dataset may comprise one or more database atoms.
- the one or more logical atoms may be represented in a first schema.
- the one or more database atoms may be represented in a second schema.
- the first schema may be a predicate based schema.
- the one or more logical atoms may be represented using predicate representation.
- the second schema may be a non-predicate based schema.
- the one or more database atoms may be represented comprising the path to selectively access the one or more data sources.
- the one or more data sources may comprise databases, ontologies, application program interface calls, web services, or a combination thereof.
- the one or more data sources may be heterogeneous data sources.
- the one or more heterogeneous data sources may comprise databases, ontologies, application program interface calls, and web services.
- plan state denotes a state of a world.
- the plan state is represented as combination of a set of logical atoms and a set of database atoms that may change during the planning process.
- the state of the plan system i.e. the plan state may undergo change as determined by post conditions of the actions included in the plan.
- the plan state S mentioned may be represented by equation (1) S - > la *
- 'la' represents a logical atom.
- the logical atom may be represented in predicate form.
- the logical atom comprises a logical atom head and a set logical atom arguments.
- a fact - "amount of available cash is 10,000" may be represented in the plan state as the logical atom 'available cash' represented as (avail-cash 10000).
- avail-cash is the logical atom head and 10000 is an argument of the logical atom.
- the prior art plan state representation suffers from shortcomings such as practicability, scalability and modularity. Hence the plan state representation has become a requirement towards improvement.
- a modification in plan state is disclosed.
- the system comprises a framework to provide the plan state representation in a modified form.
- the modification in the plan state may comprise representation of the plan state using combination of the one or more logical atoms and the one or more database atoms.
- the plan state representation using combination of the one or more logical atoms and the one or more database atoms provides a support for use of heterogeneous data sources (such as for booking flight ticket various data sources of agents, flights, weather can be used).
- the plan state may comprise the first data set and the second dataset.
- the first dataset may comprise the one or more logical atoms.
- the one or more logical atoms may be represented in predicate form.
- the one or more logical atoms may represent frequently changeable data (dynamic data) using predicate based schema.
- the predicate based schema may indicate representation of the one or more logical atoms in the predicate form.
- the predicate form is a symbolic formal system used to represent facts or information that is true. By way of the above explained example a fact or information is "amount of available cash is 10,000".
- the predicate representation of the fact is (avail-cash 10000).
- available cash of a person is represented using logical atom in predicate form as an application of different operators on the logical atom may change value of the logical atom frequently.
- the logical atoms related to available cash, agent, flight, hotel may be represented in the predicate form as shown below.
- the second dataset may comprise the one or more database atoms.
- the one or more database atoms may be represented in non-predicate schema.
- the non-predicate schema may indicate representation of the one or more database atoms in non-predicate form.
- non-predicate representation may be a representation other than predicate representation.
- An example of the non-predicate form of representation is natural language.
- state facts may be represented as 'amount of available cash is 10,000, 6 is even number'.
- less frequently changing data or not changing data may be stored in one or more database atoms in the non-predicate form.
- non-predicate schema By way of an example, an agent's information (travel agent name, address, contact number, charge etc.), or flight information (flight name, flight number, source, destination, cost, number of hops, departure, arrival, duration etc.), or the hotel information (hotel name, location, class, type, price etc.) of a city is represented using non-predicate data source such as database atoms as shown below.
- the representation of the database atoms in the non-predicate based schema and the selective access of the database atoms from the one or more heterogeneous data sources using the path makes the plan state scalable, practical and modular, and wherein cache memory is used to store the database atoms so fetched.
- the logical atoms indicating dynamically varying data continually resides in the memory during the generation of the plan, whereas the database atoms indicating the static data is selectively loaded in the memory only when required during the generation of the plan, thereby facilitating optimal utilization of the memory and reducing data retrieval overhead during the generation of the plan.
- a connection may be added to the second dataset to access optimal data associated with the database atoms selectively.
- the optimal data associated with the database atoms may be required during planning.
- the optimal data associated with the database atoms may be accessed by using the path as represented in the database atoms.
- the receiving module 212 may receive a task list in the problem definition.
- the task list may define tasks.
- the receiving module 212 may receive a domain definition.
- the domain definition may comprise a set of task methods and a set of task operators.
- the set of task methods may be of non-primitive type and the set of task operators may be of primitive type.
- the primitive type of task operator may indicate atomic work which can be directly accomplished by operator.
- E.g. "!set-agent” denotes a task operator of primitive type.
- the non-primitive type of task method may indicate a work or an action that may not be accomplished directly and may need to be decomposed into subtasks.
- E.g. "BookTicket” denotes task method of the non-primitive type.
- Logical representation of the task method may comprise the task method precondition and the one or more subtasks.
- the task method precondition may comprise a logical precondition and/or a database precondition.
- the logical representation of the task operator may comprise the task operator precondition and an effect list.
- the task operator precondition may comprise the logical precondition and/or the database precondition.
- the effect list may comprise instructions for deletion or addition of the one or more logical atoms or deletion or addition the one or more database atoms.
- the task method may be decomposed into subtasks if the pre-condition mentioned in the task method is satisfied by the plan state that is the first dataset and/or the second dataset.
- the task method may comprise a first precondition and one or more subtasks.
- the first precondition may be at least one of a logical precondition and a database precondition.
- the task operator may comprise a second precondition and an action list.
- the second precondition may be at least one of the logical precondition and the database precondition.
- the action list may comprise instructions for deletion or addition of one or more logical atoms or deletion or addition of one or more database atoms.
- the task method may be decomposed into the one or more sub-tasks.
- the task method may indicate an action to be accomplished by executing the one or more sub-tasks.
- the sub-task may be a task method or a task operator.
- the task operator may indicate an atomic action to be accomplished directly without any further decomposition.
- the task method may be executed by decomposing the task method into the one or more sub-tasks.
- One or more variables of the first set of variables of the task method may be assigned to one or more sub-task arguments associated with the one or more subtasks.
- the one or more sub-tasks may be added to the task in order to iteratively execute the one or more subtasks.
- the task operator may be executed by selecting and modifying at least one of one or more logical atoms and one or more database atoms. At least one of a logical atom and a database atom may be added to the logical atoms and the database atoms respectively, based on the execution of the task operator.
- the execution of the sub-task may comprise validating at least one of the first precondition and the second precondition, assigning at least one of the first set of variables and the second set of variables, and either decomposing the task method, assigning at least one of the first set of variables and the second set of variables, and adding one or more sub-tasks to the task, or modifying one or more logical atoms, or one or more database atoms.
- the task "BookTicket” is first unified with a task method head.
- the task is decomposed into a subtask “agent” if the precondition "(choose ?p)" is satisfied by plan state.
- the task operator may complete the work/action/task if the pre-condition mentioned in the operator is satisfied by the plan state.
- some of the logical atoms may be deleted from the first dataset or the second dataset (if permitted) and some of the logical atoms may be added into the first dataset or the second dataset (if permitted).
- the task operator may complete a action/primitive task "set-agent” if the precondition "(avail-cash ?x)" is satisfied by the current plan state i.e. the first dataset and second dataset.
- the receiving module 212 may receive a problem definition.
- the problem definition may comprise one or more logical atoms, one or more database atoms, and the task list.
- the one or more database atoms may be represented with a path to selectively access the one or more database atoms from the one or more data sources.
- the one or more logical atoms and the one or more database atoms may be required to complete the task.
- the problem definition may be a file containing description of the information to be used to complete the task.
- the information required to complete the task may comprise one or more logical atoms, one or more database atoms and the task list.
- the problem definition may be the plan state in which the task may be completed.
- the task is to book a ticket and the primary information/data required to complete the task of booking the ticket.
- the primary information comprises three logical atoms such as available cash information and information about two agents.
- the task is to book a ticket from Rico to London and using cash upto 30000, using a flight via an agent.
- the problem definition for the task to book a ticket is represented as followed.
- the receiving module 212 may receive a domain definition.
- the domain definition may comprise a representation of the set of task methods, a representation of the set of task operators.
- the set of task methods and the set of task operators may be provided in the domain definition and may be required to complete the task.
- the domain definition may comprise actions namely the set of task methods, the set of task operators used to complete the task mentioned in the task list.
- the domain definition may be provided by a domain descriptor and the problem definition may be provided by the user.
- the planning module 214 may select a task method from the set of task methods or a task operator from the set of task operators.
- the task method or the task operator may be selected by using the problem definition and the domain definition and by matching the task with the set of task methods and the set of task operators.
- the matching of the task with the set of task methods and the set of task operators may comprise matching of a task head with the task method head or matching of the task head with the task operator head.
- the task method head may be mentioned in the representation of the task method and the task operator head is mentioned in the representation of the task operator.
- the task head may be compared with the task method head of each task method from the set of task methods.
- the task head may be compared with the task operator head of each task operator from the set of task operators.
- the matching of the task with the set of task methods and the set of task operators is called as unification of the task method or the task operator.
- the unification of the task method or the unification of the task operator may be done by matching the task name (known as task-head) with the task method name (known as method-head) or the task operator name (known as operator-head).
- the task can be unified with more than one task method or more than one task operator at a time. But, only one task method or one task operator is selected by the planning module to complete the task.
- the adaptation module 216 and planning module 214 may be configured to execute at least one of the task method and the task operator in order to complete the task.
- the execution of the task method or the execution of the task operator may comprise verifying whether a precondition associated with one of the task method and the task operator is valid.
- the precondition may be a logical expression of one or more variables.
- the precondition may be verified by comparing the one or more variables with the one or more logical atoms or the one or more database atoms in order to match the one or more variables with the one or more logical atoms or the one or more database atoms.
- the comparing or matching of the one or more database atom may be facilitated using the path mentioned in representation of the one or more database atoms.
- the precondition associated with the task method may be a method precondition defined in the task method and the precondition associated with the task operator may be an operator precondition defined in the task operator.
- a precondition (method precondition) of the task method "BookTicket” is (choose ?p).
- the task "BookTicket” may be decomposed into a subtask “agent” if the precondition "(choose ?p)" is satisfied by plan state.
- a task operator "set-agent” can be applied to complete a task “set-agent” if the precondition "(avail-cash ?x)" is satisfied by the current plan state i.e. the first dataset and the second dataset.
- the logical atom "(avail-cash ?x)” is deleted and two logical atoms such as booking details i.e.”(booked-through ?a)” and updated available cash after booking i.e. "(avail-cash (call - ?x ?b))” are added to the first data set.
- a precondition associated with the task method and/or a precondition associated with the task operator may be NULL.
- NULL implies no precondition.
- the 'addlist', the 'deletelist' part of the task operator may also be NULL.
- the precondition may be represented as a logical expression of predicate based logical atoms as well as non-predicate based database atoms. Modification in task operator's effect may be obtained which refer to the modifications in the predicate based logical atoms as well as modifications in the non-predicate based database atoms based on the requirement.
- the database atoms may be stored in the one or more data sources. Further, the system and method of the present disclosure handles overhead caused by the database atoms by use of the adaptation module 216 without modifying the planning process.
- the overhead caused by the non-predicate based database atoms may be connection establishment to the one or more data sources to access the database atoms, to fetch the database atoms, to verify the precondition associated with the database atoms and the like.
- the adaptation module 216 may add a connection to the second dataset to access a database atom and fetch the database atom by using the path as represented in the database atom.
- the one or more logical atoms and the one or more database atoms may be supplied to the adaptation module 216.
- the adaptation module 216 may be plugged in with other planners like classical planner to avail advantages mentioned in the present disclosure.
- the adaptation module 216 can also be reused for data gathering purpose. In the proposed framework the problem definition and domain definition may be two inputs to the adaptation module 216.
- the adaptation module 216 may assign the one or more variables with one or more values when the precondition is valid.
- the one or more values may be obtained from the at least one logical atom and/or the at least one database atom so matched with the one or more variables.
- the adaptation module 216 may execute the task operator.
- the execution of the task operator may comprise verifying the precondition associated with the task operator and if the precondition is satisfied, may be modifying the one or more logical atoms from the first dataset and/or modifying the one or more database atoms from the second dataset.
- the adaptation module 216 may modify the logical atom, and/or the database atom as mentioned into the task operators' effect part.
- the modification of the at least one logical atom and the at least one database atom may be based on execution of the task operator.
- the adaptation module 216 may add new one or more logical atoms to the first dataset and to add new one or more database atoms to the second dataset based on the execution of one of the task operator.
- the new one or more logical atoms are not present in the first data set initially and the new one or more database atoms, are not present in the second data set initially.
- cache memory may be used to store the one or more database atoms fetched.
- the adaptation module 216 may fetch the one or more database atoms from the data sources to verify the precondition associated with the one or more database atoms.
- the one or more database atoms so fetched may be needed in near future to verify another precondition.
- the so fetched one or more database atoms are kept into the cache memory. Therefore, while verifying another precondition, if the adaptation layer gets a non-predicate precondition, first the adaptation module checks the one or more database atoms into the cache memory. Further, if the one or more database atoms are not matched with a database atom mentioned in the precondition, then the adaptation module 216 may check into data source using the path mentioned in the database atom.
- the planning module may decompose the task method into one or more subtasks when the task method is selected.
- the planning module may assign one or more values of arguments/variables of the task method to one or more sub-tasks' arguments.
- the planning module may add the one or more sub-tasks to the task list in order to execute the one or more subtasks.
- the adaptation module and planning module may execute the one or more subtasks.
- the one or more sub-tasks may be executed by iteratively selecting the sub task from the task list.
- the tasks and the sub-tasks may be selected based on priority, as mentioned in the task list. Further, the execution of sub-task may comprise selection of a task method from the set of task methods or a task operator from the set of task operators by using the problem definition and the domain definition and by matching the sub-task head with each task method's head from the set of task methods and by matching the sub-task head with each task operator's head from the set of task operators.
- the execution of sub-task may further comprise executing at least one of the task method and/or the task operator so selected in order to complete the sub-task.
- the sub-task may be executed using similar steps as mentioned in the execution of the task.
- the execution of the at least one of the task method and the task operator comprises verifying whether a precondition associated with one of the task method and the task operator is valid.
- the precondition is a logical expression of one or more variables.
- the precondition is verified by comparing the one or more variables with the one or more logical atoms or the one or more database atoms in order to match the one or more variables with at least one logical atom or at least one database atom.
- the comparing of the one or more database atom is facilitated using the path provided in the database atom representation.
- the adaptation module 216 may facilitate optimized use of the data and optimized use of the memory in the planning process.
- the adaptation module 216 may verify the precondition with the first dataset and the second dataset.
- the precondition may be associated with the task method or the task operator.
- the precondition may comprise logical atoms and/or database atoms.
- the adaptation module 216 may connect to the database "agent”, sorts the entries from the database agent based on "charge” and returns a tuple with least value of charge associated with the agent.
- agent information represented as (agent thomascook 500) and (agent reachfar 600) need to be loaded into main memory of the planning system since agent thomascook and agent reachfar are declared using predicate based schema.
- execution of the at least one of the task method and the task operator may comprise assigning the one or more variables with one or more values when the precondition is valid.
- the one or more values may be obtained from the one or more logical atoms or the one or more database atoms so matched with the one or more variables.
- execution of the one or more sub-tasks comprises iteratively performing the selecting of the task method and/or the task operator, the executing of the task method and/or the task operator for each sub-task from the task list.
- the above said steps are performed iteratively for each sub-task from the task list by selecting and executing each sub-task from the task list till there is no sub-task remaining in the task list.
- the execution of the sub-task comprises the verifying the precondition, the assigning the one or more variables, the decomposing the task method, the assigning one or more arguments/variables and adding the one or more sub-tasks to the task list.
- the sub-task is executed as execution of the task.
- the planning module 214 may generate the plan based upon the execution of at least one of the task and the one or more sub-tasks.
- the plan may be generated by using the problem definition and the domain definition.
- “Bookticket” is to execute "agent”, “set-agent”, “book-via-agent”, “book-transport-flight”, “book-ticket” methods and operators.
- a task list is received by the receiving module.
- the planning module (212) unifies the chosen task with a task method or a task operator, matching a task head with the task methods' head (for non-primitive task) or matching a task head with the task operators' head (for primitive task) based on the source of task methods and task operators stored in the system database.
- the planning module selects the unified task method(s) or unified task operator(s) and may pass the unified task method(s) or unified task operator(s) to the adaptation module (216).
- the adaptation module (216) then verifies the precondition of the task method(s) and task operator(s), with respect to the current plan state.
- the plan state comprises a first dataset comprising a plurality of logical atoms and a second dataset comprising plurality of database atoms.
- the pluralities of logical atoms are represented in predicate passed schema and plurality of database atoms are represented in non-predicate based schema.
- a precondition is a logical expression of variables indicative of logical atoms and database atoms.
- step 404 the variables (constituents) of the precondition (logical expression) are verified whether the variables (constituents) are logical atoms (predicates) or database atoms (non-predicates). So, satisfaction of the precondition depends on the matching of the logical atoms and database atoms from the plan state with the variables (constituents) of the logical expression.
- the matching of the logical atoms and database atoms from the plan state with the variables of the precondition (logical expression) is carried out in step 405 and 406 respectively. If there are no such logical atoms or the database atoms present in the plan state, the truth value of precondition becomes false, otherwise true. When the truth value of the precondition becomes false, the system 102 exits and stops.
- the adaptation module verifies availability for the set of logical atoms in the plan state.
- adaptation module fetches specified data and checks that the data present in the data source can satisfy the precondition or not.
- the satisfaction of the verification associated with the logical atoms indicates presence of the logical atoms in the first dataset. Satisfaction of the verification associated with the database atoms indicates presence of the database atoms in the second dataset.
- the adaptation module 216 substitutes variables mentioned in the precondition with the grounded value.
- the grounded values are the values obtained from the one or more logical atoms or the one or more database atoms that satisfies the precondition.
- the adaptation module 216 further assigns the grounded value to the uninstantiated argument list of the task method or the task operator.
- 'p' is 'uninstantiated' variable which is instantiated by value 'agent'.
- the planning module selects an applicable task method or task operator and in step 409 the planning module decomposes the task methods into sub-tasks and the planning module adds the decomposed task of the task method to the task list.
- the adaptation module executes the task operator's effect part.
- the task Operator' effect part contains "deletelist" and "addlist”.
- the adaptation module 216 in step 410 modifies the predicate(s) accordingly. Otherwise, the adaptation module 216 in step 411, checks for the permission of modification for non-predicate data from the data sources (in the case of dynamic data maintained in non-predicate based data sources). If the modification of the non-predicate data is permitted and required, then in step 412 adaptation module connects to the data sources and modifies that is adds or deletes or updates the non-predicate data accordingly.
- Figure 4 represents the process flowchart. Whenever the control passes from planning module to adaptation module or vice versa, the passing of control is mentioned within the bracket in the process flowchart.
- implementation of the system 102 for generating the plan to complete the task in the computing environment is provided.
- Incorporation of use of heterogeneous data sources in the planning system requires significant modification in grammar rule as well as in the domain definition and the problem definition.
- the modifications in the grammar rule, the domain definition and the problem definition are provided by way of an example considering database as the non-predicate information source is provided.
- grammar rule The modification in grammar rule is explained.
- the keywords e.g. and, call, imply etc.
- grammar terminals e.g. :method, :sort-by, :first etc.
- Any logical expression starts with :import-db refers to a database.
- the modification in domain definition is explained.
- the domain definition also requires some syntactic, operational modifications.
- the modification in precondition as mentioned in the domain definition is explained.
- the domain definition comprises the task methods and the task operators that may be used by the planning module and the adaptation module to complete the task.
- Precondition mentioned above is associated with both (task method and task operator). Equation 3 and 4 represents syntax of precondition.
- precondition lp represents the logical precondition which is actually logical expression ( le ) or first satisfier precondition or sorted precondition.
- Precondition( FIRST le ) compels planning module (along with adaptation module) to consider only the first set of bindings with respect to plan state that satisfies le .
- Planning module (along with adaptation module) may not consider the next bindings even if the first bindings do not lead to a valid plan.
- SORT VARID ( d )? le instructs the planning module to consider bindings in decreasing or increasing order using fid depending on the values of variable VARID.
- the logical expression may be a logical atom or any complex expression of conjunctions, disjunctions, negations, implications, universal quantifications, assignments, or call expressions.
- the modified logical expression of the precondition is provided as in Equation 5 below.
- a database atom consists of a da head and an argument list.
- the database atom head contains server name, database name, driver setting and the table name.
- the argument list of database atom refers to the uninstantiated variables.
- the uninstantiated argument list is instantiated with the values obtained from database tables.
- the uninstantiated variables mentioned in the precondition are instantiated by the values fetched from the database. If a data associated with the database atom needs to be fetched from the database table with restriction (some specific value for a particular column), the column name needs to be mentioned within third bracket of the database atom representation. Otherwise, if a data needs to be fetched without restriction, the column names of the table may or may not be mentioned. In this case, declaration of the column names is optional.
- the variables of database atom (da) are substituted after precondition checking. Syntactically the basic database precondition is represented as,
- the adaptation module When the adaptation module reads the basic database precondition, the adaptation module uses the already established connections and obtains data from the databases by executing a sql query mentioned below by way of an example.
- the plan state may contain more than one logical atom (predicate) that satisfies the precondition.
- the logical expression mentioned in the precondition can filter the logical atoms (predicates) that satisfy the precondition by applying restrictions such as call, sort-by etc. For example, the logical expression starts with sort-by, sorts the logical atoms (predicates) on some arguments mentioned in the argumentlist and passes the top most predicate to the adaptation module.
- the restrictions may be handled by formulating equivalent sql query. An example of such precondition and equivalent sql query is provided below. Sort-by database precondition:
- the modification in effect other than the precondition part such as syntactic modification is also required in the task operator's effect part that is in addlist and deletelist is explained.
- the addlist and deletelist can change database entry.
- the static data may be kept in the database table and therefore no modifications are required (insert and delete).
- Addlist can refer update and addition of value in the database table and deletelist may refer deletion of data in the database table. Syntactically, the addlist and deletelist may be represented as similar database precondition expression.
- the server name the database (db) name, driver settings, table name may follow similar notation as mentioned earlier.
- the adaptation module 216 may add or delete corresponding logical atom (predicate) in the first dataset.
- the addlist and deletelist refers to a database record, adaptation module may first check write permission of corresponding database. If permitted for addlist the adaption layer may execute equivalent sql query by way of an example shown below,
- the task is to book a ticket by selecting an agent and a flight.
- the domain definition consists of four task methods and two task operators. The functionality of each task method and each task operator is discussed below. The task method details are provided as herein.
- Task Method - BookTicket checks the option for booking ticket and chooses booking according to the option.
- Task Method - agent finds agents, their charges and selects an agent with least charge.
- Task Operator - set-agent add an agent name in plan state, modify available cash after selecting the agent.
- Task Method - book-via-agent selects flight as transport mode.
- Task Method - book-transport-flight checks flight options and selects a flight for given source and destination whose fare is less than the available cash.
- Task Operator - book-ticket adds flight number in plan state and modifies the cash available after booking the flight.
- the problem definition comprises three predicates (logical atoms) and two database atoms (references to databases) and the task list.
- the predicates declare booking options, transport mode options, available cash at initial stage.
- MySQL is the database used herein.
- the agent database contains the name of the agents (Aname) and the charges (Charge) associated with the agents for booking a ticket.
- the flight database contains flight information such as flight mode, flight number, source, destination, fare, start time, finish time, duration of flight and number of hops.
- the task list defines the task of booking a ticket.
- the problem definition is given below.
- task list comprises only one task is "BookTicket”.
- the planning module unifies the task method "BookTicket” for the task “BookTicket”.
- Unification of the task method for the task comprises matching a task head of the task with a task method head of the task method.
- Logical precondition - (choose ?p) associated with the task method "BookTicket” is verified with respect to given plan state information comprising the first dataset and the second dataset for (choose agent). So, the uninstantiated argument list comprising one or more variables of the precondition is substituted with value (agent) of from the first dataset.
- the task "BookTicket” is decomposed into sub-task "agent”. Values of the tasks' arguments (x, y, z, m) are assigned from the task method "BookTicket” argument list and from the precondition verification of the task method "BookTicket”. The decomposed sub-tasks are added to the task list.
- the next sub-task is "agent” for which a task method "agent” is unified.
- the precondition is a restricted database precondition and refers to a table "agent”.
- the restriction is given by sort-by.
- the restricted database precondition finds an agent name from "agent” table whose charge is least. So, the adaptation module executes an equivalent SQL query provided below. SELECT * FROM agent ORDER BY charge ASC;
- the variables of the decomposed task that is sub-task are assigned in a similar way of method "BookTicket”.
- the sub-task "set-agent” and “book-via-agent” are added to the task list.
- the task "set-agent” is a primitive task.
- the planning module unifies the subtask “set-agent” with “set-agent” task operator.
- the precondition associated with the task operator "set-agent” is verified by plan state predicates (avail-cash 100000).
- plan state predicates availability of plan-agent.
- the (deletelist) refers a plan state predicate (logical atom) such as (avail cash 100000) deletion.
- the addlist refers to addition of the predicate 'avail cash' with modified argument value in plan state. Since by example if the agent selected is of cost 20000 the modified avail-cash value is 80000.
- Execution of task operator constitutes of unifying task head with operator head, verifying precondition and adding and/or deleting facts from the plan state.
- "book-via-agent” task method is unified by the planning module.
- Precondition associated with the "book-via-agent” task method is verified by the logical atoms (plan state predicates) such as (transport-mode-mod flight train bus) and decomposed sub-task "book-transport-flight” is added to the task list.
- "book-transport-flight” sub-task is unified with a task method "book-transport-flight”.
- the task method has a database precondition restricted by "call”.
- the argument list of decomposed non-primitive sub-task "book-ticket” is assigned and the sub-task is added to the task list.
- the planning module unifies "book-ticket” task operator for "book-ticket” task.
- the precondition (avail-cash ?x) associated with "book-ticket” task operator is verified with respect to the first dataset (predicate plan state).
- the effect part of the "book-ticket” task operator modifies the available cash after booking the flight ticket and adds a new predicate (logical atom) stating the mode and booked flight number to the first dataset.
- the system 102 terminates after above step as no more sub-tasks exist in the task list.
- a method 500 for generating a plan to complete a task in a computing environment is shown, in accordance with an embodiment of the present subject matter.
- the method 500 may be described in the general context of computer executable instructions.
- computer executable instructions can include routines, programs, objects, components, data structures, procedures, modules, functions, etc., that perform particular functions or implement particular abstract data types.
- the method 500 may also be practiced in a distributed computing environment where functions are performed by remote processing devices that are linked through a communications network.
- computer executable instructions may be located in both local and remote computer storage media, including memory storage devices.
- the order in which the method 500 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 500 or alternate methods. Additionally, individual blocks may be deleted from the method 500 without departing from the spirit and scope of the subject matter described herein. Furthermore, the method can be implemented in any suitable hardware, software, firmware, or combination thereof. However, for ease of explanation, in the embodiments described below, the method 500 may be considered to be implemented in the above described system 102.
- a method (500) for generating a plan to complete a task in a computing environment is described.
- the method comprises receiving a problem definition.
- the problem definition comprises a first dataset and a second dataset.
- the first dataset and the second dataset are associated with the task.
- the first dataset comprises one or more logical atoms
- the second dataset comprises one or more database atoms, wherein the one or more logical atoms are represented in a first schema, and wherein the one or more database atoms are represented in a second schema.
- the one or more database atoms are represented with a path to selectively access the one or more database atoms from the one or more data sources.
- the one or more logical atoms and the one or more database atoms are required to complete the task.
- the problem definition further comprises a task list, wherein the task list defines the task.
- the one or more data sources may be heterogeneous data sources.
- the one or more heterogeneous data sources comprise databases, ontologies, application program interface calls, and web services.
- Cache memory may be used to store the database atoms so fetched.
- the logical atoms may indicate dynamically varying data and the logical atoms may continually reside in the memory during the generation of the plan, whereas the database atoms may indicate the static data and may be selectively loaded in the memory only when required during the generation of the plan, thereby facilitating optimal utilization of the memory and reducing data retrieval overhead during the generation of the plan.
- a connection may be added to the second dataset to access optimal data associated with the database atoms selectively, required during planning, by using the path as represented in the database atoms.
- the method comprises receiving a domain definition.
- the domain definition comprises a set of task methods, a set of task operators, wherein the set of task methods are of non-primitive type and the set of task operators are of primitive type,
- the method comprises selecting a task method from the set of task methods or a task operator from the set of task operators by matching the task with the set of task methods and the set of task operators.
- the planning module 214 selects the task method from the set of task methods or the task operator from the set of task operators by matching the task with the set of task methods and the set of task operators. More particularly, the planning module 214 selects the task method from the set of task methods or the task operator from the set of task operators by matching the task head with each task method's head from the set of task methods and by matching the task head with each task operator's head from the set of task operators.
- the task method may comprise a first precondition and one or more subtasks, wherein the first precondition may be at least one of a logical precondition and a database precondition.
- the task operator may comprise a second precondition and an action list.
- the second precondition may be at least one of the logical precondition and the database precondition.
- the action list may comprise instructions for deletion or addition of one or more logical atoms or deletion or addition of one or more database atoms.
- the method comprises executing at least one of the task method and the task operator in order to complete the task.
- the adaptation module and the planning module executes the task method or the task operator.
- the execution of the task method or the execution of the task operator comprises following steps (steps 510 - 522).
- the execution of the task method or the execution of the task operator comprises verifying whether a precondition associated with one of the task method and the task operator is valid or not.
- the precondition is a logical expression of one or more variables.
- the precondition is verified by comparing the one or more variables with the one or more logical atoms or the one or more database atoms in order to match the one or more variables with at least one logical atom or at least one database atom.
- the comparing of the one or more database atoms is facilitated using the path mentioned in the representation of the one or more database atoms.
- the execution of the task method or the execution of the task operator further comprises assigning the one or more variables with one or more values when the precondition is valid.
- the one or more values are obtained from the at least one logical atom or the at least one database atom so matched with the one or more variables.
- the execution of the task method further comprises decomposing the task method into one or more sub-tasks when task method is selected and task method precondition is satisfied.
- the task method may be decomposed into the one or more sub-tasks, and wherein the task method may indicate an action to be accomplished by executing the one or more sub-tasks.
- the sub-task may be a task method or a task operator.
- the task operator may indicate an atomic action to be accomplished directly without any further decomposition.
- the method further comprises adding at least one of a logical atom and a database atom to the logical atoms and the database atoms respectively, based on the execution of the task operator.
- the execution of the task method further comprises assigning one or more arguments of the task method to the one or more sub-tasks.
- the task method may be executed by decomposing the task method into the one or more sub-tasks, assigning one or more variables of the first set of variables of the task method to one or more sub-task arguments associated with the one or more sub-tasks, and adding the one or more sub-tasks to the task in order to iteratively execute the one or more subtasks.
- the task operator may be executed by selecting and modifying at least one of one or more logical atoms and one or more database atoms.
- step 518 the execution of the task method further comprises adding the one or more sub-tasks to the task list in order to execute the one or more subtasks.
- step 510 verifying a precondition associated with one of the task method and the task operator and in step 512 assigning the one or more variables with one or more values are carried out by the adaptation module 216.
- step 514 decomposing the task method into one or more sub-tasks, in step 516 assigning one or more arguments of the task method to the one or more sub-tasks, in step 516 adding the one or more sub-tasks to the task list is carried out by the planning module 214.
- the method 500 further comprises in step 520 executing the one or more subtasks by iteratively performing the selecting, the executing each sub-task from the task list.
- the adaptation module 216 and the planning module 214 executes the one or more sub-tasks.
- the execution of the sub-task may comprise validating at least one of the first precondition and the second precondition, assigning at least one of the first set of variables and the second set of variables, and either decomposing the task method, assigning at least one of the first set of variables and the second set of variables, and adding one or more sub-tasks to the task, or modifying one or more logical atoms, or one or more database atoms.
- the execution of the task operator comprises verifying the precondition associated with the task operator and if the precondition is satisfied, modifying the logical atom in the first dataset and/or modifying the database atom in the second dataset.
- the first schema is predicate based schema
- the one or more logical atoms are represented using predicate logic
- the second schema is non-predicate based schema
- the database atoms are represented comprising the path to access the one or more data sources.
- the method 500 further comprises modifying, the one or more logical atoms, and the one or more database atoms, and wherein the modification of the one or more logical atoms and the one or more database atoms is based on execution of the task operator.
- the adaptation module 216 modifies, the one or more logical atoms, and the one or more database atoms.
- the method 500 further comprises adding a connection to the second dataset to access data associated with the one or more database atoms by using the path as represented in the one or more database atoms.
- the method 500 further comprises using the connection from the second dataset to fetch the data associated with the one or more database atoms by using the path as represented in the one or more database atoms.
- the method 500 further comprises adding new one or more logical atoms to the first dataset and to add new one or more database atoms to the second dataset based on the execution of one of the task operator wherein the new one or more logical atoms are not present in the first data set initially and the new one or more database atoms are not present in the second data set initially.
- the method 500 further comprises using cache memory to store the data associated with the one or more database atoms fetched.
- the method 500 comprises generating the plan based upon the execution of the task and each sub-task from the task list.
- the planning module 214 generates the plan based upon the execution the task and each sub-task from the task list.
- the steps of the method (500), such as, the receiving, the selecting, the executing, the verifying, the assigning, the decomposing, the assigning, the adding, the executing, the modifying, the adding the connection, the using the connection and the generating are performed by means of a processor.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Business, Economics & Management (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- Human Resources & Organizations (AREA)
- Economics (AREA)
- Strategic Management (AREA)
- Entrepreneurship & Innovation (AREA)
- Computational Linguistics (AREA)
- Artificial Intelligence (AREA)
- Evolutionary Computation (AREA)
- Mathematical Physics (AREA)
- Data Mining & Analysis (AREA)
- Computing Systems (AREA)
- Educational Administration (AREA)
- Game Theory and Decision Science (AREA)
- Development Economics (AREA)
- Marketing (AREA)
- Operations Research (AREA)
- Quality & Reliability (AREA)
- Tourism & Hospitality (AREA)
- General Business, Economics & Management (AREA)
- Management, Administration, Business Operations System, And Electronic Commerce (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
Description
- The present subject matter described herein, in general, relates to intelligent systems for planning, and more particularly to planning systems for generating a plan in a computing environment.
- In a field of artificial intelligence, planning is a process of selecting and organizing actions by considering expected outcomes or goals. In planning process plan state denotes a state of the world and is represented as a set of state facts. During the planning process the plan state undergoes changes as determined by post conditions of actions included in a plan. The planning system has to select and execute a set of actions in order to reach a goal state.
- Current planning techniques or particularly plan state representation techniques suffer from many limitations such as practicability, scalability and modularity. In real world scenario, the planning system needs to access a collection of information available from heterogeneous data sources. The heterogeneous data sources include databases, ontology, application program interface calls and web services and the like. However the current planning techniques do not consider heterogeneity of information in the plan state. Hence, the practicability limitation in the planning systems is not solved.
- Further, conventional planning techniques do not provide optimized use of data during generation of the plan. The conventional planning techniques use the monolithic predicate based schema for the plan state representation, wherein a world state is described as a set of predicates that are currently true. On the contrary in reality the world state has to be obtained by aggregating information from different modular sources represented through multiple knowledge representation techniques. Further performance of the planning system may be affected when size of the plan state is enormously large. Thus the conventional planning techniques face many challenges in providing efficient and optimized plan state representation during plan generation.
- In practical cases, the plan state may be enormously large which in turn may affect performance of the planning system. As an example, the HTN (Hierarchical Task Network) planner, JSHOP2 (a Java implementation of Simple Hierarchical Ordered Planner) suffers from scalability problem for the plan state having large number of state facts represented in a monolithic predicate-based schema. The state facts comprise frequently varying data and static data. Hence the frequently varying data and the static data, both represented in the monolithic predicate-based schema resides continuously in the memory of the planning system. This results in over utilization of memory. Further, during planning complete set of information (all state facts) is loaded into memory of the planning system, whereas only a part of the complete set of information is actually required at various points of executions in generation of the plan. Hence loading of large amount of information in the memory of the planning system results in computational overhead and further leads to scalability problem.
- In general data sources follow modularity approach. For example, data comprising weather information, road information and transport information may be maintained in database systems. Further separate tables may be used to store the data. Therefore a change in one module or a table does not affect the change in other modules or tables of the database systems. The current plan state representation does not follow the modularity approach as the information in the plan state is presented using the monolithic predicate-based schema.
- This summary is provided to introduce aspects related to systems and methods. System for generating a plan to complete a task in a computing environment and the aspects are further described below in the detailed description. 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.
- In one implementation, a method for generating a plan to complete a task in a computing environment is described. The method comprises representing a plan state comprising a first dataset and a second dataset. The first dataset and the second dataset are associated with a task. The second dataset is received from one or more heterogeneous data sources. The first dataset comprises logical atoms represented in a predicate-based schema. The second dataset comprises database atoms represented in a non-predicate based schema. The logical atoms indicate a dynamically varying data to be accessed frequently. The database atoms indicate a static data. A database atom of the database atoms is represented with a path. The path facilitates selective access of the database atoms from the one or more heterogeneous data sources. The method further comprises iteratively selecting task methods from a set of predefined task methods and task operators from a set of predefined task operators, by matching with a task to be completed. The method further comprises successively executing the task methods and the task operators, as selected, in order to complete the task. The execution of a task method of the task methods and a task operator of the task operators include validating a first precondition associated with the task method and a second precondition associated with the task operator, by matching a first set of variables associated with the task method and a second set of variables associated with the task operator, with at least one of the logical atoms and the database atoms. The matching of the database atoms is facilitated using the path. The execution of the task method and the task operator further include assigning the first set of variables with a first set of values when the first precondition is valid and the second set of variables with a second set of values when the second precondition is valid. The first set of values and the second set of values are obtained from one or more logical atoms of the logical atoms and one or more database atoms of the database atoms, so matched with the first set of variables and the second set of variables respectively. The execution of the task method and the task operator further include executing the task method using the first set of values and executing the task operator using the second set of values. The method further comprises generating the plan based upon the execution of the task methods and the task operators.
- The representation of the database atoms in the non-predicate based schema and the selective access of the database atoms from the one or more heterogeneous data sources using the path makes the plan state scalable, practical and modular. Cache memory is used to store the database atoms so fetched. The logical atoms indicating dynamically varying data continually resides in the memory during the generation of the plan, whereas the database atoms indicating the static data is selectively loaded in the memory only when required during the generation of the plan, thereby facilitating optimal utilization of the memory and reducing data retrieval overhead during the generation of the plan. The one or more heterogeneous data sources comprise databases, ontologies, application program interface calls, and web services.
- In one implementation, a system for generating a plan to complete a task in a computing environment is described. The system comprises a processor and a memory coupled to the processor. The processor is capable of executing programmed instructions stored in the memory. The programmed instructions are executed for representing a plan state comprising a first dataset and a second dataset, associated with a task. The second dataset is received from one or more heterogeneous data sources. The first dataset comprises logical atoms represented in a predicate-based schema. The second dataset comprises database atoms represented in a non-predicate based schema. The logical atoms indicate a dynamically varying data to be accessed frequently. The database atoms indicate a static data. A database atom of the database atoms is represented with a path. The path facilitates selective access of the database atoms from the one or more heterogeneous data sources. The programmed instructions are further executed for iteratively selecting task methods from a set of predefined task methods and task operators from a set of predefined task operators, by matching with a task to be completed. The programmed instructions are further executed for successively executing the task methods and the task operators, as selected, in order to complete the task. The execution of a task method of the task methods and a task operator of the task operators include validating a first precondition associated with the task method and a second precondition associated with the task operator, by matching a first set of variables associated with the task method and a second set of variables associated with the task operator, with at least one of the logical atoms and the database atoms. The matching of the database atoms is facilitated using the path. The execution of the task method and the task operator further include assigning the first set of variables with a first set of values when the first precondition is valid and the second set of variables with a second set of values when the second precondition is valid. The first set of values and the second set of values are obtained from one or more logical atoms of the logical atoms and one or more database atoms of the database atoms, so matched with the first set of variables and the second set of variables respectively. The execution of the task method and the task operator further include executing the task method using the first set of values and executing the task operator using the second set of values. The programmed instructions are further executed for generating the plan based upon the execution of the task methods and the task operators.
- In one implementation, a non-transitory computer readable medium embodying a program executable in a computing device for generating a plan to complete a task in a computing environment is described. The program comprises a program code for representing a plan state comprising a first dataset and a second dataset, associated with a task. The second dataset is received from one or more heterogeneous data sources. The first dataset comprises logical atoms represented in a predicate-based schema. The second dataset comprises database atoms represented in a non-predicate based schema. The logical atoms indicate a dynamically varying data to be accessed frequently. The database atoms indicate a static data. A database atom of the database atoms is represented with a path, wherein the path facilitates selective access of the database atoms from the one or more heterogeneous data sources. The program further comprises a program code for iteratively selecting task methods from a set of predefined task methods and task operators from a set of predefined task operators, by matching with a task to be completed. The program further comprises a program code for successively executing the task methods and the task operators, as selected, in order to complete the task. The execution of a task method of the task methods and a task operator of the task operators include validating a first precondition associated with the task method and a second precondition associated with the task operator, by matching a first set of variables associated with the task method and a second set of variables associated with the task operator, with at least one of the logical atoms and the database atoms, and wherein the matching of the database atoms is facilitated using the path. The execution of the task method and the task operator further include assigning the first set of variables with a first set of values when the first precondition is valid and the second set of variables with a second set of values when the second precondition is valid. The first set of values and the second set of values are obtained from one or more logical atoms of the logical atoms and one or more database atoms of the database atoms, so matched with the first set of variables and the second set of variables respectively. The execution of the task method and the task operator further include executing the task method using the first set of values and executing the task operator using the second set of values. The program further comprises a program code for generating the plan based upon the execution of the task methods and the task operators.
- 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.
-
Figure 1 illustrates a network implementation of a system for generating a plan to complete a task in a computing environment is shown, in accordance with an embodiment of the present subject matter. -
Figure 2 illustrates the system for generating the plan to complete the task in the computing environment, in accordance with an embodiment of the present subject matter. -
Figure 3 illustrates a framework of the system for generating the plan to complete the task in the computing environment, in accordance with an embodiment of the present subject matter. -
Figure 4 illustrates a process flow chart for generating the plan to complete the task in the computing environment, in accordance with an embodiment of the present subject matter. -
Figure 5 illustrates a method for generating a plan to complete a task in a computing environment, in accordance with an embodiment of the present subject matter. - System(s) and method(s) for generating a plan to complete a task in a computing environment are described. The system provides a framework that facilitates use of heterogeneous data sources to represent a plan state in order to generate the plan. The system and method facilitates representation of the plan state. The plan state representation comprises combination of information in predicate form as well as references to information in non-predicate form stored in a variety of data sources like databases, ontologies etc. The plan state representation using information from distributed heterogeneous data sources, without altering planning algorithm in concern is disclosed. Hence according to the present disclosure, the system provides a framework capable of handling the non-predicate based data along with the predicate based data and a provision to access the non-predicate based data from the plan state on demand basis. Key aspect of the present disclosure is to handle overheads caused by the non-predicate based data without changing main planning process.
- The system and method for generating the plan may comprise receiving one or more logical atoms, and one or more database atoms. The one or more logical atoms may be represented in a first schema, and the one or more database atoms may be represented in a second schema. The first schema may be predicate based schema. The logical atoms may be represented using predicate logic. The second schema may be non-predicate based schema and representation of the database atom comprises a path to selectively access the database atom stored in one or more data sources. The system and method may further receive a task list in a form of task network, set of task methods and set of task operators required to complete the task. The task list defines a task.
- Further, the system and method select and execute a task method and/or a task operator iteratively from the set of task methods and the set of task operators to complete the task. The execution of the task method and the task operator may comprise iteratively verifying precondition associated with the task method and the task operator for validity. Precondition may be a logical expression of variables mentioned in a task method representation and a task operator representation. The precondition may be verified by comparing variables of the task method or the task operator with the logical atoms or the database atoms in order to match the variables with the logical atoms or the database atoms.
- When the precondition is valid, the variables are assigned with the values obtained from the logical atoms and/or the database atoms so matched with the variables. When the task method is selected, the task method is decomposed into sub-tasks, and the values of the arguments/variables of the task method is assigned to the arguments of the subtasks, and the sub-tasks are added to the task list in order to execute the subtasks. The subtasks may be executed by iteratively performing the selection and the execution of each subtask. Further, the system may generate the plan based upon the execution of all the tasks and sub-tasks form the task list.
- While aspects of described system and method for generating a plan to complete a task in a computing environment may be implemented in any number of different computing systems, environments, and/or configurations, the embodiments are described in the context of the following exemplary system.
- Referring now to
figure 1 , anetwork implementation 100 of asystem 102 for generating a plan to complete a task in a computing environment is illustrated, in accordance with an embodiment of the present subject matter. In one embodiment, thesystem 102 may select a task method from the set of task methods and/or a task operator from the set of task operators and may execute the task method and/or the task operator. In one embodiment, thesystem 102 may verify whether a precondition associated with the task method and/or the task operator is valid. After verifying the precondition, one or more variables of the precondition may be assigned with one or more values when the precondition is valid. In another embodiment, when the task method is selected, the system may decompose the task method into one or more sub-tasks and may iteratively execute the one or more sub-tasks in order to complete the task. In another embodiment, the system may generate the plan based on the execution of the task and each of the sub-tasks from the task list. - Although the present subject matter is explained considering that the
system 102 is implemented on a server, it may be understood that thesystem 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, thesystem 102 may be implemented in a cloud-based environment. It will be understood that thesystem 102 may be accessed by multiple users through one or more user devices 104-1, 104-2...104-N, collectively referred to asuser devices 104 hereinafter, or applications residing on theuser devices 104. Examples of theuser devices 104 may include, but are not limited to, a portable computer, a personal digital assistant, a handheld device, and a workstation. Theuser devices 104 are communicatively coupled to thesystem 102 through anetwork 106. - In one implementation, the
network 106 may be a wireless network, a wired network or a combination thereof. Thenetwork 106 can 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. Thenetwork 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 thenetwork 106 may include a variety of network devices, including routers, bridges, servers, computing devices, storage devices, and the like. - Referring now to
Figure 2 , thesystem 102 is illustrated in accordance with an embodiment of the present subject matter. In one embodiment, thesystem 102 may include at least oneprocessor 202, an input/output (I/O)interface 204, and amemory 206. The at least oneprocessor 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, the at least oneprocessor 202 is configured to fetch and execute computer-readable instructions stored in thememory 206. - 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 thesystem 102 to interact with a user directly or through theclient devices 104. Further, the I/O interface 204 may enable thesystem 102 to communicate with other computing devices, such as web servers and external data servers (not shown). The I/O interface 204 can 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. - 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. Thememory 206 may includemodules 208 anddata 210. - The
modules 208 include routines, programs, objects, components, data structures, etc., which perform particular tasks, functions or implement particular abstract data types. In one implementation, themodules 208 may include areceiving module 212, aplanning module 214, anadaptation module 216, andother modules 218. Theother modules 218 may include programs or coded instructions that supplement applications and functions of thesystem 102. The programs include programmed instructions. - The
data 210, amongst other things, serves as a repository for storing data processed, received, and generated by one or more of themodules 208. Thedata 210 may also include asystem database 222, andother data 224. Theother data 224 may include data generated as a result of the execution of one or more modules in theother module 218. - In one implementation, at first, a user may use the
client device 104 to access thesystem 102 via the I/O interface 204. The user may register using the I/O interface 204 in order to access thesystem 102. The working of thesystem 102 may be explained in detail by referring to details ofFigures 2 and3 . Thesystem 102 may be used to generate a plan. Thesystem 102 may be used to generate the plan to complete a task in a computing environment. In order to complete the task, thesystem 102, at first, receives data. Specifically, in the present implementation, the system receives data through the receivingmodule 212. - Referring to
Figure 2 , detailed working of thesystem 102 is illustrated, in accordance with an embodiment of the present subject matter. Referring tofigure 2 , the detailed working of the receivingmodule 212 along with working of other components of thesystem 102 is illustrated, in accordance with an embodiment of the present subject matter. The receivingmodule 212 may receive a problem definition. The problem definition may comprise a first dataset and a second dataset. The first dataset and the second dataset may be associated with the task. By way of an example the task may be booking a ticket, moving packages between locations by trucks under certain spatial constraints and delivering deadlines, finding a sequence of biochemical (pathways) reactions in an organism producing certain substances, traveling and buying goods at selected markets minimizing costs and the like. The first dataset may be generated and the second dataset may be received from one or more data sources. The first dataset may comprise one or more logical atoms. The second dataset may comprise one or more database atoms. The one or more logical atoms may be represented in a first schema. The one or more database atoms may be represented in a second schema. The first schema may be a predicate based schema. The one or more logical atoms may be represented using predicate representation. The second schema may be a non-predicate based schema. The one or more database atoms may be represented comprising the path to selectively access the one or more data sources. The one or more data sources may comprise databases, ontologies, application program interface calls, web services, or a combination thereof. - The one or more data sources may be heterogeneous data sources. The one or more heterogeneous data sources may comprise databases, ontologies, application program interface calls, and web services.
- In a field of artificial intelligence, planning is a process of selecting and organizing actions by considering expected outcomes or goals. In a planning process, a plan state denotes a state of a world. The plan state is represented as combination of a set of logical atoms and a set of database atoms that may change during the planning process. During the planning process, the state of the plan system i.e. the plan state may undergo change as determined by post conditions of the actions included in the plan. The plan state S mentioned may be represented by equation (1)
In equation (1), 'la' represents a logical atom. The logical atom may be represented in predicate form. The logical atom comprises a logical atom head and a set logical atom arguments. For example, a fact - "amount of available cash is 10,000" may be represented in the plan state as the logical atom 'available cash' represented as (avail-cash 10000). Here, avail-cash is the logical atom head and 10000 is an argument of the logical atom. The prior art plan state representation suffers from shortcomings such as practicability, scalability and modularity. Hence the plan state representation has become a requirement towards improvement. - According to an embodiment of the present disclosure, a modification in plan state is disclosed. The system comprises a framework to provide the plan state representation in a modified form. The modification in the plan state may comprise representation of the plan state using combination of the one or more logical atoms and the one or more database atoms. The plan state representation using combination of the one or more logical atoms and the one or more database atoms provides a support for use of heterogeneous data sources (such as for booking flight ticket various data sources of agents, flights, weather can be used).
- According to an embodiment of the present disclosure, the plan state may comprise the first data set and the second dataset. The first dataset may comprise the one or more logical atoms. The one or more logical atoms may be represented in predicate form. The one or more logical atoms may represent frequently changeable data (dynamic data) using predicate based schema. The predicate based schema may indicate representation of the one or more logical atoms in the predicate form. The predicate form is a symbolic formal system used to represent facts or information that is true. By way of the above explained example a fact or information is "amount of available cash is 10,000". The predicate representation of the fact is (avail-cash 10000). By way of an example, available cash of a person is represented using logical atom in predicate form as an application of different operators on the logical atom may change value of the logical atom frequently. The logical atoms related to available cash, agent, flight, hotel may be represented in the predicate form as shown below.
- (avail-cash 10000)
- (agent thomascook 500)
- (agent reachfar 600)
- (flight-info flight IC814 kolkata london 40000 9 22 13 1)
- (flight-info flight KF334 kolkata london 30000 11 23 12 0)
- (hotel-info princess-hotel london 4 3500)
- (hotel-
info travelodge london 3 3600) - The second dataset may comprise the one or more database atoms. The one or more database atoms may be represented in non-predicate schema. The non-predicate schema may indicate representation of the one or more database atoms in non-predicate form. In one embodiment, non-predicate representation may be a representation other than predicate representation. An example of the non-predicate form of representation is natural language. By way of a non limiting example, state facts may be represented as 'amount of available cash is 10,000, 6 is even number'. In one embodiment, less frequently changing data or not changing data (static data) may be stored in one or more database atoms in the non-predicate form. Thus by way of storing the less frequently changing data or non-changing data (static data) in a second schema i.e. non-predicate schema the frequent access of the data and frequent modification can be avoided. By way of an example, an agent's information (travel agent name, address, contact number, charge etc.), or flight information (flight name, flight number, source, destination, cost, number of hops, departure, arrival, duration etc.), or the hotel information (hotel name, location, class, type, price etc.) of a city is represented using non-predicate data source such as database atoms as shown below.
- (:import-db mysql agentDB jdbc:mysql://localhost:3306 user user123 agent)
- (:import-db mysql flightDB jdbc:mysql://localhost:3306 user user123 flight)
- (:import-db mysql hotelDB jdbc:mysql://localhost:3306 user user123 hotel)
- The representation of the database atoms in the non-predicate based schema and the selective access of the database atoms from the one or more heterogeneous data sources using the path makes the plan state scalable, practical and modular, and wherein cache memory is used to store the database atoms so fetched.
- The logical atoms indicating dynamically varying data continually resides in the memory during the generation of the plan, whereas the database atoms indicating the static data is selectively loaded in the memory only when required during the generation of the plan, thereby facilitating optimal utilization of the memory and reducing data retrieval overhead during the generation of the plan. A connection may be added to the second dataset to access optimal data associated with the database atoms selectively. The optimal data associated with the database atoms may be required during planning. The optimal data associated with the database atoms may be accessed by using the path as represented in the database atoms.
- Referring to
figure 2 and3 , the receivingmodule 212 may receive a task list in the problem definition. The task list may define tasks. The receivingmodule 212 may receive a domain definition. The domain definition may comprise a set of task methods and a set of task operators. The set of task methods may be of non-primitive type and the set of task operators may be of primitive type. The primitive type of task operator may indicate atomic work which can be directly accomplished by operator. E.g. "!set-agent" denotes a task operator of primitive type. The non-primitive type of task method may indicate a work or an action that may not be accomplished directly and may need to be decomposed into subtasks. E.g. "BookTicket" denotes task method of the non-primitive type. - Logical representation of the task method may comprise the task method precondition and the one or more subtasks. The task method precondition may comprise a logical precondition and/or a database precondition. The logical representation of the task operator may comprise the task operator precondition and an effect list. The task operator precondition may comprise the logical precondition and/or the database precondition. The effect list may comprise instructions for deletion or addition of the one or more logical atoms or deletion or addition the one or more database atoms. The task method may be decomposed into subtasks if the pre-condition mentioned in the task method is satisfied by the plan state that is the first dataset and/or the second dataset.
- The task method may comprise a first precondition and one or more subtasks. The first precondition may be at least one of a logical precondition and a database precondition. The task operator may comprise a second precondition and an action list. The second precondition may be at least one of the logical precondition and the database precondition. The action list may comprise instructions for deletion or addition of one or more logical atoms or deletion or addition of one or more database atoms.
- The task method may be decomposed into the one or more sub-tasks. The task method may indicate an action to be accomplished by executing the one or more sub-tasks. The sub-task may be a task method or a task operator. The task operator may indicate an atomic action to be accomplished directly without any further decomposition.
- The task method may be executed by decomposing the task method into the one or more sub-tasks. One or more variables of the first set of variables of the task method may be assigned to one or more sub-task arguments associated with the one or more subtasks. The one or more sub-tasks may be added to the task in order to iteratively execute the one or more subtasks. The task operator may be executed by selecting and modifying at least one of one or more logical atoms and one or more database atoms. At least one of a logical atom and a database atom may be added to the logical atoms and the database atoms respectively, based on the execution of the task operator. The execution of the sub-task may comprise validating at least one of the first precondition and the second precondition, assigning at least one of the first set of variables and the second set of variables, and either decomposing the task method, assigning at least one of the first set of variables and the second set of variables, and adding one or more sub-tasks to the task, or modifying one or more logical atoms, or one or more database atoms.
- In the following example of a task method, the task "BookTicket" is first unified with a task method head. The task is decomposed into a subtask "agent" if the precondition "(choose ?p)" is satisfied by plan state.
(:method(BookTicket ?x ?y ?z ?m ?p) //task method head and arguments ((choose ?p)) //task method precondition ((agent ?x ?y ?z ?m))) //decomposed task
(:operator (!set-agent ?a ?b) //task operator head and argument ((avail-cash ?x)) //task operator precondition ((avail-cash ?x)) //task operator delete list ((booked-through ?a)(avail-cash (call - ?x ?b)))) //task operator add list
(defproblem problem CITY ----------------------Initial plan state----------------------- ( (avail-cash 100000) (agent thomascook 500) (agent reachfar 600) ) --------------Task list for a task of 'Bookticket'-------------------- ((BookTicket kolkata london 30000 flight agent)))
(:method(BookTicket ?x ?y ?z ?m ?p) //task method head and arguments ((choose ?p)) //precondition ((agent ?x ?y ?z ?m))) //decomposed task
(:operator (!set-agent ?a ?b) ((avail-cash ?x)) ((avail-cash ?x)) ((booked-through ?a)(avail-cash (call - ?x ?b))))
In equation (2), 'la' represents logical atom and 'dba'represents database atom. Each database belongs to a server. So, a server name, a database name and a table name needs to be mentioned in the database atom. In order to establish connection with database driver settings, user name and password is also required. Hence the driver settings, the user name and the password is also mentioned in the database atom. Syntactically the database atom is represented as shown below.
- (:importdb servername dbname driversettings username password)
Precondition mentioned above is associated with both (task method and task operator).
- (servername_dbname_driversettings_tablename arg1[/col1] ... argm[/colm]).
- SELECT * FROM table name where colk = argk.
- (:sort-by ?col <(servername_dbname_driversettings_tablename arg1[/col1] ... argm[/colm)).
- SELECT * FROM table name ORDER BY col ASC;
- (servername_dbname_driversettings_tablename arg1[/col1] ... argm[/colm]).
- INSERT INTO table name VALUES (arg1, ...,argm);
- And for delete list following query is executed.
- DELETE FROM table name WHERE colk = argk;
(defdomain CITY) ( (:method(BookTicket ?x ?y ?z ?m ?p) ((choose ?p)) ((agent ?x ?y ?z ?m))) (:method (agent ?x ?y ?z ?m) (:sort-by ?q <(mysql_agentDB_jdbc:mysql://localhost:3306_agent ?p/aname ?q/charge)) ((!set-agent ?p ?q)(book-via-agent ?x ?y ?z ?m))) (:operator (!set-agent ?a ?b) ((avail-cash ?x)) ((avail-cash ?x)) ((booked-through ?a)(avail-cash (call - ?x ?b)))) (:method(book-via-agent ?x ?y ?z ?m) ((transport-mode-mod ?m ?b ?c)) ((book-transport-flight ?x ?y ?z))) (:method (book-transport-flight ?x ?y ?z) ((mysql_flightDB_jdbc:mysql://localhost:3306_flight ?a/mode ?b/fno ?x/source ?y/destination ?e/fare ?f/start ?g/finish ?h/duration ?i/hops)(call <?e ?z)) ((!book-ticket ?a ?b ?e))) (:operator (!book-ticket ?m ?c ?d) ((avail-cash ?x)) ((avail-cash ?x)) ((booked ?m ?c )(avail-cash (call - ?x ?d)))) ) )
(defproblem problem CITY ----------------------State Facts (The logical atoms and the database atoms) -------------- ( (:import-db mysql agentDB jdbc:mysql://localhost:3306 user user123 agent) (:import-db mysql flightDB jdbc:mysql://localhost:3306 user user123 flight) (transport-mode-mod flight train bus) (avail-cash 100000) (choose agent) ) --------------Task list -------------- ( (BookTicket kolkata london 30000 flight agent) )
SELECT * FROM agent ORDER BY charge ASC;
The variables of the decomposed task that is sub-task are assigned in a similar way of method "BookTicket". The sub-task "set-agent" and "book-via-agent" are added to the task list.
SELECT * FROM flight where source = x and destination = y and fare <z;
Claims (15)
- A method for optimal representation of a plan state while generating a plan to complete a task in a computing environment, wherein the optimal representation of the plan state improves efficiency of the computing environment through improved utilization of memory and reduction of overhead from data retrieval, the method comprising:providing a processor and a non-transitory memory coupled to said processor, wherein the non-transitory memory comprises programmed instructions;representing a plan state, via the processor and the non-transitory memory, comprising a first dataset and a second dataset, associated with a task, wherein the second dataset is received from one or more heterogeneous data sources, and wherein the first dataset comprises logical atoms represented in a predicate-based schema, and the second dataset comprises database atoms represented in a non-predicate based schema, wherein the logical atoms indicate a dynamically varying data to be accessed frequently, and wherein the database atoms indicate a static data, and wherein the logical atoms indicating the dynamically varying data continually resides in the memory during the generation of the plan, whereas the database atoms indicating the static data is selectively loaded in the memory only when required during the generation of the plan, thereby facilitating optimal utilization of the memory and reducing data retrieval overhead during the generation of the plan, and wherein a database atom of the database atoms is represented with a path, wherein the path facilitates selective access of the database atoms from the one or more heterogeneous data sources makes the plan state scalable, practical and modular;iteratively selecting, via the processor, task methods from a set of predefined task methods and task operators from a set of predefined task operators, by matching with a task to be completed;successively executing, via the processor, the task methods and the task operators, as selected, in order to complete the task, wherein the execution of a task method of the task methods and a task operator of the task operators includevalidating a first precondition associated with the task method and a second precondition associated with the task operator, by matching a first set of variables associated with the task method and a second set of variables associated with the task operator, with at least one of the logical atoms and the database atoms, and wherein the matching of the database atoms is facilitated using the path,assigningthe first set of variables with a first set of values when the first precondition is valid, andthe second set of variables with a second set of values when the second precondition is valid,wherein the first set of values and the second set of values are obtained from one or more logical atoms of the logical atoms and one or more database atoms of the database atoms, so matched with the first set of variables and the second set of variables respectively,executingthe task method using the first set of values andthe task operator using the second set of values; andgenerating, via the processor, a plan based upon the execution of the task methods and the task operators.
- The method of claim 1, wherein the one or more heterogeneous data sources comprise databases, ontologies, application program interface calls, and web services.
- The method of claim 1, wherein the task method comprises the first precondition and one or more subtasks, wherein the first precondition is at least one of a logical precondition and a database precondition, and wherein the task operator comprises the second precondition and an action list, wherein the second precondition is at least one of the logical precondition and the database precondition, and wherein the action list comprises instructions for deletion or addition of one or more logical atoms or deletion or addition of one or more database atoms.
- The method of claim 5, wherein the task method is decomposed into the one or more sub-tasks, and wherein the task method indicates an action to be accomplished by executing the one or more sub-tasks, and wherein the sub-task is a task method or a task operator, and wherein the task operator indicates atomic action to be accomplished directly without any further decomposition.
- The method of claim 6, wherein the task method is executed by decomposing the task method into the one or more sub-tasks, assigning one or more variables of the first set of variables of the task method to one or more sub-task arguments associated with the one or more sub-tasks, and adding the one or more sub-tasks to the task in order to iteratively execute the one or more subtasks.
- The method of claim 5, wherein the task operator is executed by selecting and modifying at least one of one or more logical atoms and one or more database atoms.
- The method of claim 1, wherein a connection is added to the second dataset to access optimal data associated with the database atoms selectively, required during planning, by using the path as represented in the database atoms.
- The method of claim 1, wherein at least one of a logical atom and a database atom is added to the logical atoms and the database atoms respectively, based on the execution of the task operator.
- The method of claim 6, wherein the execution of the sub-task comprises validating at least one of the first precondition and the second precondition, assigning at least one of the first set of variables and the second set of variables, and either decomposing the task method, assigning at least one of the first set of variables and the second set of variables, and adding one or more sub-tasks to the task, or modifying one or more logical atoms, or one or more database atoms.
- A system for optimal representation of a plan state while generating a plan to complete a task in a computing environment wherein the optimal representation of the plan state improves efficiency of the computing environment through improved utilization of memory and reduction of overhead from data retrieval,, the system comprising:a processor;a memory coupled to the processor, wherein the processor is capable of executing programmed instructions stored in the memory for:representing a plan state comprising a first dataset and a second dataset, associated with a task, wherein the second dataset is received from one or more heterogeneous data sources, and wherein the first dataset comprises logical atoms represented in a predicate-based schema, and the second dataset comprises database atoms represented in a non-predicate based schema, wherein the logical atoms indicate a dynamically varying data to be accessed frequently, and wherein the database atoms indicate a static data, and wherein the logical atoms indicating the dynamically varying data continually resides in the memory during the generation of the plan, whereas the database atoms indicating the static data is selectively loaded in the memory only when required during the generation of the plan, thereby facilitating optimal utilization of the memory and reducing data retrieval overhead during the generation of the plan, and wherein a database atom of the database atoms is represented with a path, wherein the path facilitates selective access of the database atoms from the one or more heterogeneous data sources makes the plan state scalable, practical and modular;iteratively selecting task methods from a set of predefined task methods and task operators from a set of predefined task operators, by matching with a task to be completed;successively executing the task methods and the task operators, as selected, in order to complete the task, wherein the execution of a task method of the task methods and a task operator of the task operators includevalidating a first precondition associated with the task method and a second precondition associated with the task operator, by matching a first set of variables associated with the task method and a second set of variables associated with the task operator, with at least one of the logical atoms and the database atoms, and wherein the matching of the database atoms is facilitated using the path,assigningthe first set of variables with a first set of values when the first precondition is valid, andthe second set of variables with a second set of values when the second precondition is valid,wherein the first set of values and the second set of values are obtained from one or more logical atoms of the logical atoms and one or more database atoms of the database atoms, so matched with the first set of variables and the second set of variables respectively,executingthe task method using the first set of values andthe task operator using the second set of values; andgenerating a plan based upon the execution of the task methods and the task operators.
- The system of claim 10, wherein cache memory is used to store the database atoms so fetched.
- The system of claim 10, wherein the task method comprises the first precondition and one or more subtasks, wherein the first precondition is at least one of a logical precondition and a database precondition, and wherein the task operator comprises the second precondition and an action list, wherein the second precondition is at least one of the logical precondition and the database precondition, and wherein the action list comprises instructions for deletion or addition of one or more logical atoms or deletion or addition of one or more database atoms.
- The system of claim 10, wherein the task method is decomposed into one or more sub-tasks, and wherein the task method indicates an action to be accomplished by executing the one or more sub-tasks, and wherein the sub-task is a task method or a task operator, and wherein the task operator indicates an atomic action to be accomplished directly without any further decomposition.
- The system of claim 10, wherein the task method is executed by decomposing the task method into the one or more sub-tasks, assigning one or more variables of the first set of variables of the task method to one or more sub-task arguments associated with the one or more sub-tasks, and adding the one or more sub-tasks to the task in order to iteratively execute the one or more subtasks.
- The system of claim 10, wherein the task operator is executed by selecting and modifying at least one of one or more logical atoms and one or more database atoms.
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
IN2879MU2013 IN2013MU02879A (en) | 2013-09-05 | 2013-09-05 |
Publications (1)
Publication Number | Publication Date |
---|---|
EP2849084A1 true EP2849084A1 (en) | 2015-03-18 |
Family
ID=51518567
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
EP14183793.0A Withdrawn EP2849084A1 (en) | 2013-09-05 | 2014-09-05 | System and method for generating a plan to complete a task in computing environment |
Country Status (3)
Country | Link |
---|---|
US (1) | US9201692B2 (en) |
EP (1) | EP2849084A1 (en) |
IN (1) | IN2013MU02879A (en) |
Families Citing this family (9)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US9773019B2 (en) * | 2014-08-16 | 2017-09-26 | Tata Consultancy Services Limited | Creating a user's proximity model in accordance with a user's feedback |
US20160103708A1 (en) * | 2014-10-09 | 2016-04-14 | Profoundis Labs Pvt Ltd | System and method for task execution in data processing |
US10073715B2 (en) * | 2016-12-19 | 2018-09-11 | Intel Corporation | Dynamic runtime task management |
CN107341596A (en) * | 2017-06-20 | 2017-11-10 | 上海交通大学 | Task optimization method based on level Task Network and critical path method |
US20210049440A1 (en) * | 2019-08-16 | 2021-02-18 | Microsoft Technology Licensing, Llc | Smart coach for enhancing personal productivity |
US11526791B2 (en) | 2019-11-11 | 2022-12-13 | International Business Machines Corporation | Methods and systems for diverse instance generation in artificial intelligence planning |
CN110888728B (en) * | 2019-12-03 | 2022-06-28 | 中电工业互联网有限公司 | Task scheduling method of button cluster server |
CN112381230A (en) * | 2020-11-16 | 2021-02-19 | 吉林大学 | Action sequence reasoning method of military action ontology based on hierarchical mission network |
CN115455903B (en) * | 2022-11-10 | 2023-01-31 | 北京云枢创新软件技术有限公司 | System for verifying operational characters |
Family Cites Families (6)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JPS60114968A (en) | 1983-11-28 | 1985-06-21 | Hitachi Ltd | Automatic layout forming system |
US20070204020A1 (en) | 2006-02-24 | 2007-08-30 | International Business Machines Corporation | System and method of stream processing workflow composition using automatic planning |
US8848214B2 (en) | 2008-11-26 | 2014-09-30 | Xerox Corporation | System and method for automatically validating a workflow plan using an automated planner |
US8649042B2 (en) | 2009-07-24 | 2014-02-11 | Xerox Corporation | System and method for automated generation of a fully parameterized workflow plan |
US8745637B2 (en) | 2009-11-20 | 2014-06-03 | International Business Machines Corporation | Middleware for extracting aggregation statistics to enable light-weight management planners |
US8862614B2 (en) | 2010-08-05 | 2014-10-14 | Carnegie Mellon University | Planning-based automated fusing of data from multiple heterogeneous sources |
-
2013
- 2013-09-05 IN IN2879MU2013 patent/IN2013MU02879A/en unknown
-
2014
- 2014-09-05 EP EP14183793.0A patent/EP2849084A1/en not_active Withdrawn
- 2014-09-05 US US14/478,447 patent/US9201692B2/en active Active
Non-Patent Citations (1)
Title |
---|
JÜRGEN DIX ET AL: "IMPACTing SHOP: Putting an AI Planner Into a Multi-Agent Environment", ANNALS OF MATHEMATICS AND ARTIFICIAL INTELLIGENCE, 1 April 2003 (2003-04-01), Dordrecht, pages 381 - 407, XP055167954, Retrieved from the Internet <URL:http://www.cs.umd.edu/~nau/papers/dix2003impacting.pdf> [retrieved on 20150206], DOI: 10.1023/A:1021560510377 * |
Also Published As
Publication number | Publication date |
---|---|
US9201692B2 (en) | 2015-12-01 |
IN2013MU02879A (en) | 2015-07-03 |
US20150067690A1 (en) | 2015-03-05 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9201692B2 (en) | System and method for generating a plan to complete a task in computing environment | |
US11037345B2 (en) | Systems and methods for processing computational workflows | |
JP6659544B2 (en) | Automated experimental platform | |
US11886507B2 (en) | Multi-tenant knowledge graph databases with dynamic specification and enforcement of ontological data models | |
Aridhi et al. | A MapReduce-based approach for shortest path problem in large-scale networks | |
JP7378975B2 (en) | Information processing equipment and information processing system | |
Deng et al. | A distributed PDP model based on spectral clustering for improving evaluation performance | |
CN110347386A (en) | A kind of method, apparatus and electronic equipment of the data visualization analysis based on SQL code editor | |
US9342809B2 (en) | Method and apparatus to populate asset variant relationships in repositories | |
US10547565B2 (en) | Automatic determination and just-in-time acquisition of data for semantic reasoning | |
Schikuta | NeuroWeb: an Internet-based neural network simulator | |
US20220188691A1 (en) | Machine Learning Pipeline Generation | |
US20150100948A1 (en) | Irreducible modules | |
Buck Woody et al. | Data Science with Microsoft SQL Server 2016 | |
Quiroz-Fabián et al. | VPPE: A novel visual parallel programming environment | |
Honan et al. | A quantum computer operating system | |
Wöhrer et al. | Modeling and optimizing large-scale data flows | |
Lu et al. | Distributed execution of multidimensional programming languages. | |
US20230196156A1 (en) | Hamiltonian decomposition using mid-circuit operations | |
Janjic et al. | Using erlang skeletons to parallelise realistic medium-scale parallel programs | |
Mauro | Constraints meet concurrency | |
Vlantis et al. | On-Line Big-Data Processing for Visual Analytics with Argus-Panoptes | |
Aman et al. | Verification of Multi-agent Systems with Timeouts for Migration and Communication | |
Jin et al. | Single binding of data and model parallelisms to parallelize convolutional neural networks through multiple machines | |
Levar | Web-based platform for dataflow processing |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
PUAI | Public reference made under article 153(3) epc to a published international application that has entered the european phase |
Free format text: ORIGINAL CODE: 0009012 |
|
17P | Request for examination filed |
Effective date: 20140905 |
|
AK | Designated contracting states |
Kind code of ref document: A1 Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MK MT NL NO PL PT RO RS SE SI SK SM TR |
|
AX | Request for extension of the european patent |
Extension state: BA ME |
|
R17P | Request for examination filed (corrected) |
Effective date: 20150918 |
|
RBV | Designated contracting states (corrected) |
Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MK MT NL NO PL PT RO RS SE SI SK SM TR |
|
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: EXAMINATION IS IN PROGRESS |
|
17Q | First examination report despatched |
Effective date: 20170526 |
|
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: EXAMINATION IS IN PROGRESS |
|
STAA | Information on the status of an ep patent application or granted ep patent |
Free format text: STATUS: THE APPLICATION IS DEEMED TO BE WITHDRAWN |
|
18D | Application deemed to be withdrawn |
Effective date: 20221019 |