Dependency graph based natural language processing

• US 10,747,958 B2
• Filed: 12/19/2018
• Issued: 08/18/2020
• Est. Priority Date: 12/19/2018
• Status: Active Grant

• Current Assignee: Accenture Global Solutions Limited (Accenture PLC)
• Original Assignee: Accenture Global Solutions Limited (Accenture PLC)
• Inventors: Nelson, Paul Edward, Alvarado Solano, Esteban Alberto, Alfaro Flores, Rafael Guillermo
• Primary Examiner(s): Nguyen, Khai N.
• Application Number:
  US16/226,132
• Publication Number:
  US 20200201940A1
• Time in Patent Office: 608 Days
• Field of Search: 704 9
• CPC Class Codes: G06F 40/211 Syntactic parsing, e.g. based on context-free grammar [CFG] or unification grammars
• CPC Class Codes: G06F 40/242 Dictionaries
• CPC Class Codes: G06F 40/279 Recognition of textual entities
• CPC Class Codes: G06F 40/284 Lexical analysis, e.g. tokenisation or collocates
• CPC Class Codes: G06F 40/30 Semantic analysis
• CPC Class Codes: G06N 20/00 Machine learning

Abstract

Examples of automatically generating natural language pipelines to process an input to generate tags, semantic or syntactic, are described. In an example, on receiving a request to process input data to generate tags, a dependency graph, based on identified dependees and further dependees may be created to satisfy the request, the dependency graph including natural language operations arranged in order of their dependencies on each other. Based on the dependency graph, a pipeline for the tags may be automatically generated, which includes a series of natural language operations such that the operations for dependee tags are processed before any of their associated depender tags. Further, the dependency graph and the automated pipeline generation allows for automated optimization of the pipeline, training, re-training, testing and regression testing of the semantic tags and supporting machine learning models and provides a framework to efficiently manage the sharing and reuse of semantic understanding operations.

Claims

1. A system comprising:

a processor;

a data reader coupled to the processor to receive a request to process input data to generate tags, the tags being one of semantic tags and syntactic tags;

a natural language processor comprising natural language processing operations to tag the input data with the tags to provide for interpreting of the input data, wherein the natural language processing operations include depender operations and dependee operations, and wherein the depender operations require tagged output of the dependee operations as input;

a dependency graph generator, coupled to the processor to;

identify dependees of the tags, and further dependees of the dependees of the tags, a dependee being one of a tag and a natural language operation upon which the tag depends, wherein at least one of natural language processing operations and resources required to provide an input for a natural language operation to generate the tags is identified for each dependent and further dependents; and

create a dependency graph, based on the identified dependents and the further dependents, the dependency graph including the natural language processing operations, corresponding dependents, and corresponding further dependents arranged in an order of and linked by their dependencies; and

a pipeline generator coupled to the processor to,

generate a pipeline including a series of natural language operations ordered as they appear in the dependency graph such that the natural language operations for dependee tags are processed before any of their associated depender tags, a depender tag being a tag which depends on a dependee tag, wherein the pipeline includes a plurality of natural language processing operations to be executed in a predefined order to generate the tags; and

provide the pipeline to generate the tags for interpreting the input content.

2. The system of claim 1, wherein, upon generating the pipeline, the pipeline generator creates an optimized pipeline using the dependency graph merging a set of potentially mergeable operations in the series of natural language operations.

3. The system of claim 2, wherein to create the optimized pipeline, the pipeline generator is to:

identify a set of potentially mergeable operations in the series of natural language operations, the set of potentially mergeable operations including the natural language operations having at least one of;

identical functionality;

identical processing, component sub-operations, which take the same input and produce the same output; and

identical processing with one of different underlying configuration and different resources databases, which when merged together produce a same result as if they were processed separately;

identify a set of fully mergeable operations using the dependency graph as operations from the set of potentially mergeable operations which are capable of being merged without causing a dependency conflict, the dependency conflict being caused when a merged operation provides semantic understanding that would be computed after the natural language operation that depends on that semantic understanding based on the dependency graph;

generate an optimized pipeline with fully mergeable operations merged together; and

provide the optimized pipeline to generate the tags for interpreting the input content.

4. The system of claim 1, wherein the system further comprises an output processor coupled to the processer to:

process natural language content corresponding to the input data to obtain the tags, based on the pipeline; and

provide the tags to a client device requesting the tags.

5. The system of claim 1, wherein the system further includes an automated tag trainer coupled to the processor to:

receive a notification that a tag, from among the tags, has been modified; and

automatically retrain a modified tag and corresponding depender tags to reflect modifications made to the tag, a depender tag including one of a tag which depends on the modified tag and another tag, which depends on any tag which is retrained including dependencies of dependencies to any level of dependency nesting.

6. The system of claim 5, wherein the tag is considered to be modified when a modification events occurs, the modification event includes at least one:

changing an underlying natural language operation that produces the modified tag from natural language content including one of changing the software code which implemented the natural language operation, changing the configuration of the natural language operation, changing a resource which supplies data to the natural language operation, the resource including one of a database, a file, and an external system; and

changing natural language text processing operations that produce modified representations of the input data that are required by at least one natural language processing operation associated with the modified tag.

7. The system of claim 5, wherein the automated tag trainer to retrain the modified tag is to:

identify the depender tag corresponding to the modified tag;

construct a tag modification pipeline for each depender tag;

reprocess training content for the depender tag;

re-run machine learning training for the depender tag; and

perform a quality evaluation to determine whether the depender tag has been trained correctly.

8. The system of claim 5, wherein, when the modified tag comprises multiple depender tags, the automatic tag trainer is to retrain the multiple depender tags in parallel, based on the dependency graph, wherein parallel retraining is performed such that each tag is retrained after the tag upon which it depends, including dependencies of dependencies to any level of nesting.

9. A method comprising:

receiving a request to process input data to generate tags, the tags being one of semantic tags and syntactic tags;

identifying dependees of the tags and further dependees of the dependees of the tags, a dependee being one of a tag and a natural language operation upon which the tag depends, wherein at least one of natural language processing operations and resources required to provide an input for a natural language operation to generate the tags is identified for each dependee and further dependees, wherein the natural language processing operations include depender operations and dependee operations, and wherein the depender operation require tagged output of the dependee operations as input;

creating a dependency graph, based on the identified dependents and the further dependents, the dependency graph including the natural language processing operations, corresponding dependents, and corresponding further dependents arranged in an order of and linked by their dependencies; and

generating a pipeline including a series of natural language operations in the order as they appear in the dependency graph such that the natural language operations for dependee tags are processed before any of their associated depender tags, a depender tag being a tag which depends on a dependee tag, wherein the pipeline includes a plurality of natural language processing operations to be executed in a predefined order to generate the tags; and

providing the pipeline to generate the tags for interpreting the input content.

10. The method of claim 9, wherein the method further comprises, upon generating the pipeline, creating an optimized pipeline using the dependency graph merging a set of potentially mergeable operations in the series of natural language operations.

11. The method of claim 10, wherein creating the optimized pipeline comprises:

identifying a set of potentially mergeable operations in the series of natural language operations, the set of potentially mergeable operations including the natural language operations having at least one of;

identical functionality;

identical processing, component sub-operations, which take the same input and produce the same output; and

identical processing with one of different underlying configuration and different resources databases, which when merged together produce a same result as if they were processed separately;

identifying a set of fully mergeable operations using the dependency graph as operations from the set of potentially mergeable operations which are capable of being merged without causing a dependency conflict, the dependency conflict being caused when a merged operation provides semantic understanding that would be computed after the natural language operation that depends on that semantic understanding based on the dependency graph;

generating an optimized pipeline with fully mergeable operations merged together; and

providing the optimized pipeline to generate the tags for interpreting the input content.

12. The method of claim 9, wherein the method further comprises:

receiving a notification that a tag, from among the tags, has been modified; and

automatically retraining a modified tag and a corresponding depender tag to reflect modifications made to the tag, a depender tag including one of a tag which depends on the modified tag and another tag, which depends on any tag which is retrained including dependencies of dependencies to any level of dependency nesting.

13. The method of claim 12, wherein the tag is considered to be modified when a modification events occurs, the modification event includes at least one:

changing an underlying natural language operation that produces the modified tag from natural language content including one of changing the software code which implemented the natural language operation, changing the configuration of the natural language operation, changing a resource which supplies data to the natural language operation, the resource including one of a database, a file, and an external system; and

changing natural language text processing operations that produce modified representations of the input data that are required by at least one natural language processing operation associated with the modified tag.

14. The method of claim 12, wherein retraining the modified tag comprises:

identifying the depender tag corresponding to the modified tag;

constructing a tag modification pipeline for each depender tag;

reprocessing training content for the depender tag;

re-running machine learning training for the depender tag; and

performing a quality evaluation to determine whether the depender tag has been trained correctly.

15. The method of claim 12, wherein, when the modified tag comprises multiple the depender tags, retraining comprises retraining the multiple depender tags in parallel, based on the dependency graph, wherein parallel retraining is performed such that each tag is retrained after the tag upon which it depends, including dependencies of dependencies to any level of nesting.

16. A non-transitory computer readable medium including machine readable instructions that are executable by a processor to:

receive a request to process input data to generate tags, the tags being one of semantic tags and syntactic tags;

identify dependees of the tags and further dependees of the dependees of the tags, wherein at least one of natural language processing operations and resources required to provide an input for a natural language operation to generate the tags is identified for each dependent and further dependents, wherein the natural language processing operations include depender operations and dependee operations, and wherein the depender operation require tagged output of the dependee operations as input;

create a dependency graph, based on the identified dependents and the further dependents, the dependency graph including the natural language processing operations, corresponding dependents, and corresponding further dependents arranged in an order of and linked by their dependencies; and

generate a pipeline including a series of natural language operations ordered as they appear in the dependency graph such that the natural language operations for dependee tags are processed before any of their associated depender tags, wherein the pipeline includes a plurality of natural language processing operations to be executed in a predefined order to generate the tags; and

provide the pipeline to generate the tags for interpreting the input content.

17. The non-transitory computer readable medium of claim 16, wherein, upon generating the pipeline, the processor is to create an optimized pipeline using the dependency graph merging a set of potentially mergeable operations in the series of natural language operations.

18. The non-transitory computer readable medium of claim 17, wherein to construct the optimized pipeline the processor is to:

identify a set of potentially mergeable operations in the series of natural language operations, the set of potentially mergeable operations including the natural language operations having at least one of;

identical functionality;

identical processing, component sub-operations, which take the same input and produce the same output; and

identical processing with one of different underlying configuration and different resources databases, which when merged together produce a same result as if they were processed separately;

identify a set of fully mergeable operations using the dependency graph as operations from the set of potentially mergeable operations which are capable of being merged without causing a dependency conflict, the dependency conflict being caused when a merged operation provides semantic understanding that would be computed after the natural language operation that depends on that semantic understanding based on the dependency graph;

generate an optimized pipeline with fully mergeable operations merged together; and

provide the optimized pipeline to generate the tags for interpreting the input content.

19. The non-transitory computer readable medium of claim 16, wherein processor further includes machine executable instructions to:

receive a notification that a tag, from among the tags, has been modified; and

automatically retrain a modified tag and corresponding depender tags to reflect modifications made to the tag, a depender tag including one of a tag which depends on the modified tag and another tag, which depends on any tag which is retrained including dependencies of dependencies to any level of dependency nesting.

20. The non-transitory computer readable medium of claim 19, wherein to retrain the modified tag, the processor includes machine executable instructions to:

identify the depender tag corresponding to the modified tag;

construct a tag modification pipeline for each depender tag;

reprocess training content for the depender tag;

re-run machine learning training for the depender tag; and

perform a quality evaluation to determine whether the depender tag has been trained correctly.