Knowledge graph pattern detection and application

Abstract

The systems and methods described herein relate to expanding a knowledge graph data structure. The system accesses a knowledge graph data structure stored in a data store and pre-processes it to generate a modified knowledge graph data structure by replacing instance nodes with class nodes. The system automatically detects patterns by processing the modified knowledge graph data structure by initiating a path from a starting class node and recursively expanding the path until a stopping condition is met, where at least one attribute-class combination from a current class node in the path has a frequency of occurrence that exceeds an occurrence threshold. The system then adjusts the knowledge graph data structure based on the detected patterns.

Description

Technical Field

[0001] The topics disclosed in this paper generally relate to knowledge graph technology. Specifically, but not exclusively, this topic relates to methods and systems for detecting patterns in knowledge graphs and for applying the detected patterns to knowledge graph data structures. Background Technology

[0002] Knowledge graphs have become increasingly prevalent for organizing and managing information across diverse domains. These graph-based data structures can represent real-world entities and their relationships in flexible formats that support complex queries and analytics. Semantic techniques such as RDF (Resource Description Framework) enable knowledge graphs to define the vocabulary and rules used to represent information, while reasoning capabilities help derive additional facts from existing data. However, as the volume and complexity of information continue to grow, identifying meaningful information (e.g., patterns and relationships) within knowledge graphs presents significant technical challenges. Summary of the Invention

[0003] Technical solution

[0004] In one embodiment, a system is provided, comprising at least one memory storing instructions and one or more processors configured to perform operations when the instructions are executed, the operations including: accessing a knowledge graph data structure stored in a data store; preprocessing the knowledge graph data structure by replacing instance nodes with class nodes to generate a modified knowledge graph data structure; automatically detecting patterns by processing the modified knowledge graph data structure, including initiating a path from a starting class node in the modified knowledge graph data structure and recursively expanding the path until a stopping condition is met, wherein attribute-class combinations from current class nodes in the path have an occurrence frequency exceeding an occurrence threshold; and adjusting the knowledge graph data structure stored in the data store based on the patterns.

[0005] In another embodiment, a computer-implemented method is provided, executed by a computer system including a memory and at least one hardware processor. The computer-implemented method includes: accessing a knowledge graph data structure stored in a data storage; preprocessing the knowledge graph data structure by replacing instance nodes with class nodes to generate a modified knowledge graph data structure; automatically detecting patterns by processing the modified knowledge graph data structure, including: initiating a path from a starting class node in the modified knowledge graph data structure, and recursively expanding the path until a stopping condition is met, wherein attribute-class combinations from current class nodes in the path have an occurrence frequency exceeding an occurrence threshold; and adjusting the knowledge graph data structure stored in the data storage based on the patterns.

[0006] In another embodiment, one or more non-transitory computer-readable media are provided, storing computer-executable instructions that, when executed by a computing system, cause the computing system to perform operations including: accessing a knowledge graph data structure stored in a data store; preprocessing the knowledge graph data structure by replacing instance nodes with class nodes to generate a modified knowledge graph data structure; automatically detecting patterns by processing the modified knowledge graph data structure, including: initiating a path from a starting class node in the modified knowledge graph data structure and recursively expanding the path until a stopping condition is met, wherein attribute-class combinations from current class nodes in the path have an occurrence frequency exceeding an occurrence threshold; and adjusting the knowledge graph data structure stored in the data store based on the patterns. Attached Figure Description

[0007] Examples are shown in the accompanying drawings for illustrative purposes rather than limiting. In drawings that are not necessarily drawn to scale, the same numbers may describe similar components in different views or examples. To facilitate identification of any particular element or action being discussed, the highest significant numeral in the reference numerals refers to the drawing number in which that element was first introduced.

[0008] Figure 1 A portion of a knowledge graph based on some examples is shown.

[0009] Figure 2 It is a graphical representation of a network environment, including knowledge graph systems, based on some examples.

[0010] Figure 3 This is a block diagram illustrating the components of a knowledge graph data structure based on some examples.

[0011] Figure 4 This is a block diagram illustrating the components of a knowledge graph system based on some examples.

[0012] Figure 5 It is a graphical representation of patterns existing in a knowledge graph based on some examples.

[0013] Figure 6 This is a flowchart illustrating the operation of methods for pattern detection and application in knowledge graphs, based on some examples.

[0014] Figure 7 It is a graphical representation of a circular pattern based on some examples.

[0015] Figure 8 It is a graphical representation of an inheritance tree based on some examples.

[0016] Figure 9The data visualization of the pattern detection process in some example knowledge graphs shows the first stage.

[0017] Figure 10 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0018] Figure 11 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0019] Figure 12 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0020] Figure 13 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0021] Figure 14 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0022] Figure 15 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0023] Figure 16 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0024] Figure 17 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0025] Figure 18 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0026] Figure 19 Further data visualizations based on some examples of the pattern detection process show the next stages.

[0027] Figure 20 Further data visualization based on some examples of the pattern detection process shows that it is based on Figure 9 The patterns detected are derived from the processing of knowledge graphs.

[0028] Figure 21 This is a user interface block diagram illustrating a user interface for configuring pattern detection operations, based on some examples.

[0029] Figure 22This is a user interface block diagram illustrating, based on some examples, a user interface for displaying and managing detected patterns.

[0030] Figure 23 This is a user interface block diagram illustrating, based on some examples, a user interface for displaying and managing detected patterns.

[0031] Figure 24 This is a user interface block diagram showing a user interface for editing and adding detection modes, based on some examples.

[0032] Figure 25 It is a block diagram of a computing system based on some examples, within which instructions can be executed to perform one or more methods discussed herein. Detailed Implementation

[0033] Knowledge graphs are typically focused on a specific domain. While knowledge graphs can be continuously expanded, they are generally still considered "always incomplete" because all knowledge about a particular domain cannot be covered in a single knowledge graph. This paper describes systems and methods for detecting and applying patterns in knowledge graph data structures.

[0034] In some examples, the system and method address the significant technical challenge of expanding the information provided by knowledge graphs while maintaining large-scale consistency and integrity by implementing pattern detection methods that efficiently process graph structures to identify statistically significant patterns. Geometric analysis of class-level relations can be performed to achieve automatic expansion of ontological rules or completion of instance data, thereby improving the efficiency of knowledge graph processing or the quality of information representation.

[0035] The example system can access a knowledge graph data structure stored in a data store (e.g., a database). During preprocessing, the system generates a modified knowledge graph data structure by, for example, replacing instance nodes with class nodes. In some examples, preprocessing may include adding triple data structures to the knowledge graph data structure by materializing implicit statements based on the ontology data structure. The system can also add inverse relations to attributes in the knowledge graph data structure during preprocessing.

[0036] The system can automatically detect one or more patterns by recursively processing the modified knowledge graph data structure. In some examples, this involves initiating a path from a starting class node and recursively expanding that path until a stopping condition is met. Path expansion occurs when attribute-class combinations from the current class node have an occurrence frequency exceeding a configured threshold (e.g., a relative occurrence threshold). Stopping conditions may include detecting that the path forms a circular pattern, reaching the maximum number of iterations, or determining that no attribute-class combinations exceed the threshold.

[0037] In some examples, a recursive algorithm is used to perform pattern detection, processing the modified knowledge graph data structure in multiple phases. The system receives configuration parameters including a relative threshold for determining important relations, a maximum iteration count to limit processing depth, and optionally, a set of target categories for focusing pattern detection. During each iteration, the system analyzes the frequency of attribute-class combinations originating from the current class node to identify statistically significant connections. The pattern detection process begins by selecting one or more starting class nodes from user-specified classes or from all classes in the graph or subgraph. For each starting node, the system evaluates outgoing attribute connections and their target class nodes, calculating their frequency of occurrence to determine which combinations exceed the configured threshold. When a qualifying attribute-class combination is found, the path is extended by adding that combination and setting the target class as the new current node for the next iteration. This recursive extension continues until stopping conditions are met, such as detecting a circular pattern, reaching the maximum iteration count, or not finding a qualifying combination. In some examples, the system maintains both forward and reverse relations throughout the pattern detection process for more efficient pattern detection.

[0038] Before adjusting the knowledge graph data structure using detected patterns, the system can determine the confidence score of the detected patterns by calculating the probabilities of relations within the patterns and combining these probabilities. Patterns can be validated based on their confidence scores. In some implementations, patterns with confidence scores exceeding a threshold can be automatically incorporated into the ontology data structure of the knowledge graph.

[0039] In some examples, the system supports both automatic and user-guided pattern validation. The user interface can present detected patterns sorted by confidence scores for manual validation. In other words, the system can automatically present detected patterns in descending confidence order for acceptance or rejection. Patterns can be linear patterns that extend the ontology data structure or circular patterns that enable the automatic extension of the assertion data structure of the knowledge graph. For example, for circular patterns, the system identifies incomplete patterns in the knowledge graph data structure and generates triple data structures to complete them.

[0040] The occurrence threshold used for pattern detection can vary. In some examples, the occurrence threshold is achieved by evaluating relative frequency rather than using absolute counts. For instance, when analyzing attribute-class combinations during pattern detection, to determine if an occurrence threshold has been exceeded, the system calculates the relative frequency by dividing the number of occurrences of a specific attribute connected to instances of the target class by the total number of instances of the source class. In some examples, for a particular calculation, the occurrence threshold is chosen based on or influenced by the inheritance depth of one or more class nodes involved in the path. The system can present information about the generated triplet data structures through a user interface and add them to the assertion data structure based on user input.

[0041] In some examples, the system provides flexibility in processing scope by allowing the selection of specific categories of interest. Pattern detection can be performed in parallel when processing multiple classes. The system can handle T-Box (ontology) extensions (e.g., based on linear patterns) and A-Box (assertion) completions (e.g., based on circular patterns), with configurable thresholds and validation methods based on pattern confidence and type.

[0042] Traditional knowledge graph systems may lack effective mechanisms for automatically detecting and verifying recurring patterns in the graph structure. The example described in this paper provides automated pattern detection by recursively processing geometric analysis methods of the graph data structure. The system initiates paths from a starting class node and expands them based on the statistical frequency of occurrence exceeding a configured threshold. This enables the systematic detection of various types of patterns.

[0043] The examples in this disclosure offer several technical advantages. First, the techniques in this disclosure can reduce the time required for computational systems to find patterns in data and grow knowledge graphs, thereby saving computational resources and improving overall efficiency. Second, the techniques in this disclosure can ensure improved pattern quality, such as by detecting and applying complex patterns that might otherwise be difficult to identify or understand. Third, knowledge graph systems as described herein can increase the ease of use of knowledge graph systems for both technical and conceptual users, thereby improving technology adoption.

[0044] Furthermore, current knowledge graph computing systems face technical challenges in the large-scale, efficient analysis and processing of graph structures. This paper addresses this challenge by implementing preprocessing methods, such as replacing instance nodes with class nodes in the modified knowledge graph data structure, automatically adding reverse relationships, and materializing implicit statements before running pattern detection. This enables more efficient traversal and analysis of the graph topology.

[0045] When expanding knowledge graph data structures, knowledge graph systems may also face technical challenges in maintaining consistency. This paper describes a method to maintain consistency by handling the structured schema application process for both linear and circular schemas. For linear schemas, the system merges validated schemas into the ontology data structure to expand the schema. For circular schemas, the system identifies incomplete schemas in the knowledge graph data structure and generates triple data structures to complete them, while maintaining consistency with the underlying schemas. When confidence scores exceed a configured threshold, the system can automatically merge schemas or present them via a user interface for manual validation.

[0046] The publicly available pattern detection method provides improved accuracy and consistency for knowledge graph completion. By calculating the frequency of occurrence at the class level and validating patterns through statistical confidence scoring, the system can automatically detect and apply patterns while maintaining data quality. For circular patterns, this enables error-free graph completion. In some examples, configurable thresholds and inheritance-based tuning ensure accurate pattern detection at different levels across class hierarchies. The system's ability to perform parallel pattern detection across different starting classes further improves processing efficiency.

[0047] Typically, a knowledge graph is a database that maintains types of knowledge or information in graph form. A typical knowledge graph consists of multiple nodes representing objects (also called entities) and multiple edges connecting the nodes, where edges represent attributes as relationships between objects (e.g., is its parent, is located in, etc.). A common type of knowledge graph is based on the Resource Description Framework (RDF), which models fact statements or web resources in the form of subject-verb-object (called triples, also referred to as triple data structures in this paper). For example, two nodes connected by an edge can describe a fact, which can be represented as a (subject, verb, object) triple.

[0048] As an example, Figure 1A portion of knowledge graph 100 is shown, containing four nodes 102 representing objects "SAP_SE", "Germany", "Company", and "Country", respectively. The specific date value "1972-01-01" can also be considered an empty node 106. Knowledge graph 100 also includes edges 104 with specific attributes, such as "rdf:type", "db0:foundationPlace", and "db0:foundingYear", which represent relationships between nodes 102. Knowledge graphs can have predefined attribute prefixes (e.g., DBpedia has attribute prefixes such as "rdf", "dbo", "dbp", etc.). As shown, this knowledge graph can contain several facts, such as (SAP_SE, is the type of company), (SAP_SE, has a place of incorporation, Germany), (Germany, is the country), and (SAP_SE, has a founding year, 1972-01-01).

[0049] In some knowledge graphs (e.g., RDF knowledge graphs), reasoning can also be applied to (subject, predicate, object) triples (e.g., instead of explicitly stating "Germany" as...). Figure 1 (Examples of countries are given). For example, according to a pre-built inference rule, each object of "dbo:foundationPlace" is a country (by setting the attribute range). Therefore, by inference, the triple (dbr: Germany, rdf: type, dbo: country) can be "inferred" or "concretized" into the factual statement: "Germany is a country". Other inference rules can be constructed similarly.

[0050] Examples of computer-implemented reasoners include OWL (Web Ontology Language) reasoners, such as HermiT, Pellet, or Fact++. For instance, HermiT is a computational tool that uses a hypertableau reasoning algorithm to infer logical results from data encoded in an ontology.

[0051] Typically, some nodes can represent more specific objects and can be viewed as instances contained within the knowledge graph. For example, "SAP_SE" could represent an instance of a specific company, and "Germany" could represent an instance of a specific country. Some nodes can represent more general objects and can be viewed as class objects whose aggregations can define the ontology of the knowledge graph. The ontology of a knowledge graph can contain patterns or common lexicons that define the edges and attributes of the nodes available in the knowledge graph. For example, "company" is a class object that captures a common concept shared by many individual companies including "SAP_SE," and "country" is a class object that captures a common concept shared by many individual countries including "Germany." Therefore, Figure 1The ontology of knowledge graph 100 will define at least the following attributes for the instance "SAP_SE": "rdf:type", "dbo:foundationPlace", and "dbo:foundingYear".

[0052] Compared to relational databases, knowledge graphs typically offer more flexible data structures because the data types they provide can vary. For example, attributes associated with different instances can differ, even if these instances share the same class object (e.g., "SAP_SE" and "BASF_SE" can have different available attribute data, despite sharing the same class object "Company"). On the other hand, relational databases can be represented in a knowledge graph format; for example, a knowledge graph can be a higher-level abstraction of a relational database.

[0053] In some examples, whether a particular node (e.g., "Germany") represents an instance object or a class object can depend on the underlying model or concept. According to one example, you can determine whether the term "Germany" belongs to an ontology or an instance by checking the rdf:type attribute: if the type is owl:Class, then it belongs to the ontology; otherwise, it is considered an instance.

[0054] In some examples, for a given knowledge graph, an ontology can be created by describing class objects using a list of attributes represented by edges. Nodes in a knowledge graph can be organized hierarchically, where lower-level nodes (representing more specific objects) can be connected to higher-level nodes (representing more general objects) via one or more edges. Lower-level nodes (or the lower-level objects they represent) can be called descendants of higher-level nodes (or the higher-level objects they represent), and higher-level nodes (or the higher-level objects they represent) can be called ancestors of lower-level nodes (or the lower-level objects they represent). Therefore, different class nodes in a knowledge graph can have different inheritance depths or levels.

[0055] Figure 2 This is a schematic representation of a networked computing environment 200 in which some examples of this disclosure can be implemented or deployed. One or more servers in server system 204 provide server-side functionality to networked devices via network 202, the networked devices having an example form of user device 206 accessed by user 208. A web client 212 (e.g., a browser) or a programming client 210 (e.g., an "app") can be hosted and executed on user device 206.

[0056] Application Programming Interface (API) server 220 and web server 222 provide corresponding programming and web interfaces to the components of server system 204. Application server 218 hosts knowledge graph system 232, which may include components, modules, or applications.

[0057] User equipment 206 can communicate with application server 218 via a web interface supported by web server 222 or via a programming interface provided by API server 220. It should be understood that, although in Figure 2 Only a single user device 206 is shown in this document, but in some examples, multiple user devices may be communicatively coupled to the server system 204. Furthermore, while some functions may be described herein as being performed on user device 206 (e.g., web client 212 or programming client 210) or server system 204, the location of some functions within user device 206 or server system 204 may be a design choice.

[0058] Application server 218 is communicatively coupled to database server 224, facilitating access to one or more information repositories, such as database 226. In some examples, database 226 includes storage devices for storing information to be processed by knowledge graph system 232.

[0059] Application server 218 accesses application data (e.g., application data stored by database server 224) to provide one or more applications, features, or software tools, such as knowledge graph system 232, to user device 206 via web interface 228 or app interface 230.

[0060] Knowledge graph system 232 accesses and processes knowledge graph data structures to detect and apply patterns. In some examples, knowledge graph system 232 preprocesses the knowledge graph data structure, for instance, by replacing instance nodes with class nodes and materializing implicit statements. Knowledge graph system 232 recursively processes the modified knowledge graph data structure to detect patterns by initiating paths from the starting class nodes and expanding them based on their frequency of occurrence.

[0061] In some examples, the knowledge graph system 232 calculates a confidence score for detected patterns by determining the probability of relationships within the patterns. The knowledge graph system 232 can automatically apply patterns (e.g., by updating T-Boxes or A-Boxes) when the confidence scores exceed a configured threshold, or present them via a user interface for verification.

[0062] In some examples, the knowledge graph system 232 manages thresholds used during pattern detection, including, for example, adjusting the thresholds based on the inheritance depth of class nodes. The knowledge graph system 232 enables the configuration of processing parameters and the presentation of detected patterns for viewing via a user interface. For example, the knowledge graph system 232 can be accessed via… Figure 2 The web interface 228 or app interface 230 presents information and receives user input.

[0063] In some examples, application server 218 is part of a cloud-based platform provided by a software provider, which allows user 208 to utilize knowledge graph system 232. For example, account holders can access one or more cloud instances to communicate with knowledge graph system 232.

[0064] One or more of the application server 218, database server 224, API server 220, or web server 222 may each be implemented wholly or partially in the computer system. This may include, for example, the following regarding... Figure 25 The computing environment described. In some examples, external applications (such as external application 216 running on external server 214) can communicate with application server 218 via a programming interface provided by API server 220. For example, a third-party application may support one or more features or functions on a website or platform hosted by a third party, or may perform certain methods and provide input or output information to application server 218 for further processing or publication.

[0065] Network 202 can be any network capable of communicating between machines, databases, and devices. Therefore, network 202 can be a wired network, a wireless network (e.g., a mobile or cellular network), or any suitable combination thereof. Network 202 may include one or more components constituting a private network, a public network (e.g., the Internet), or any suitable combination thereof.

[0066] Figure 3 This is a block diagram illustrating components of a knowledge graph data structure 302 according to some examples. The knowledge graph data structure 302 can, for example, be used to store... Figure 2 The data in database 226, and can be generated by, for example Figure 2 Knowledge graph systems 232 knowledge graph systems access, process and extend.

[0067] Knowledge graph data structure 302 provides information based on a framework for organizing and storing knowledge graph information. In some examples, knowledge graph data structure 302 includes an ontology data structure 304 that defines schemas and vocabularies, and an assertion data structure 306 that contains instance-level data implementing those schemas. Knowledge graph data structure 302 enables the systematic organization of information through class-level definitions and instance-level relationships.

[0068] Ontology data structure 304 defines the schema, vocabulary, and logical rules for managing the knowledge graph. Therefore, ontology data structure 304 is associated with the T-Box of the relevant knowledge graph. In some examples, ontology data structure 304 contains class definitions, attribute types, rules and constraints, and hierarchical relationships. Ontology data structure 304 can specify domains and scopes for attributes, define relationships, and encode logical rules that enable reasoning on graph data.

[0069] exist Figure 3 In the diagram, the ontology data structure 304 is shown as including class nodes 308, attributes 310, rules and constraints 312, and hierarchy and inheritance relationships 314. Class nodes 308 represent the type or class of objects / entities within the knowledge graph schema. In some examples, class nodes 308 form a hierarchy with inheritance relationships, where subclasses inherit one or more attributes, constraints, or metadata from their parent classes.

[0070] Attribute 310 defines the type of relationship that can exist between nodes in a knowledge graph. In some examples, attribute 310 includes object properties that connect nodes and data type properties that associate nodes with text values. Attribute 310 can have a domain that specifies a valid source class and a scope that specifies a valid target class.

[0071] Rules and constraints 312 govern how knowledge graph components are connected and used. In some examples, rules and constraints 312 include data such as domain and scope restrictions on attributes, cardinality constraints, or logical rules that enable the inference of new facts. In some examples, rules and constraints 312 help maintain consistency and enable reasoning about the graph structure.

[0072] Hierarchy and inheritance 314 establishes the organizational structure between classes. In some examples, hierarchy and inheritance 314 allow subclasses to inherit properties, constraints, or metadata from their parent classes, while potentially adding their own proprietary characteristics. The depth of inheritance within these hierarchies can influence how patterns are detected and validated.

[0073] Assertion data structure 306 is shown as including instance nodes 316, relations and attributes 318, and triple data structure 320. Therefore, assertion data structure 306 is associated with the A-Box of the relevant knowledge graph. Assertion data structure 306 implements the schema defined by ontology data structure 304 to store and organize instance-level information in the knowledge graph. Assertion data structure 306 can store specific implicit and explicit statements derived through reasoning on ontology rules.

[0074] Instance nodes 316 represent specific entities or instances within the knowledge graph. In some examples, instance nodes 316 are connected to their corresponding class nodes through type relationships, allowing the system to identify the class to which each instance belongs. For example, an instance node could represent a specific painting, such as "Mona Lisa" as an instance of the "Painting" class.

[0075] Relations and attributes 318 connect instance nodes based on attributes defined in the ontology data structure. In some examples, relations and attributes 318 implement object properties that link instances, while attributes store literal values ​​associated with the instance. Relationships can be unidirectional or bidirectional.

[0076] The triplet data structure 320 stores the basic subject-predicate-object statements of a knowledge graph. For example, refer to... Figure 1 Examples are described. In some examples, the triple data structure 320 represents both explicit relations directly stated in the data and implicit relations derived through reasoning. When a pattern is detected, a new triple data structure 320 can be generated by the knowledge graph system 232 to complete the incomplete pattern while maintaining consistency with the ontology data structure 304.

[0077] The knowledge graph data structure 302 may also include knowledge graph metadata 322. The knowledge graph metadata 322 may include configuration information or statistics about the knowledge graph data structure 302. In some examples, the knowledge graph metadata 322 includes the frequency of occurrence of attribute-class combinations, confidence scores of detected patterns, and other statistics used during pattern detection and validation. The knowledge graph metadata 322 may also store system configuration parameters, such as thresholds and processing options to be implemented by the knowledge graph system 232.

[0078] Figure 4 This is shown based on some examples. Figure 2 A block diagram of the components of the knowledge graph system 232. The knowledge graph system 232 is shown as including a data access component 402, a preprocessing component 404, a pattern detection component 406, a confidence scoring component 408, a graph adjustment component 410, a pattern application component 412, a threshold configuration component 414, and a user interface component 416. In some examples, the knowledge graph system 232 is operable to manage, process, adjust, or extend components such as... Figure 3 The knowledge graph data structure 302 is a graph data structure.

[0079] Data access component 402 accesses and retrieves knowledge graph data structures stored in a data store (e.g., accessing knowledge graph data structure 302 from database 226). In some examples, data access component 402 may access ontology data structures defining schemas and vocabularies (e.g., ontology data structure 304) and assertion data structures containing instance-level data (e.g., assertion data structure 306). Data access component 402 may selectively access specific subgraphs or the entire knowledge graph data structure 302 based on configuration parameters.

[0080] The preprocessing component 404 is configured to generate a modified knowledge graph data structure by performing preprocessing operations. This may include replacing instance nodes representing information in the knowledge graph with class nodes. In some examples, the preprocessing component 404 also uses an inference engine to implement implicit statements based on the ontology data structure 304. The preprocessing component 404 can also add reverse relations for attributes that do not have a defined reverse to enable bidirectional traversal of the knowledge graph data structure 302.

[0081] Pattern detection component 406 is configured to recursively process modified knowledge graph data structures to detect patterns. In some examples, pattern detection component 406 initiates paths from starting class nodes and expands them based on attribute-class combinations that exceed a configured occurrence threshold. Pattern detection component 406 implements geometric analysis methods for examining structural relationships between class nodes, such as... Figures 9 to 20 As shown.

[0082] The confidence scoring component 408 determines the confidence score of a detected pattern by calculating the probability of relationships within the pattern. In some examples, the confidence scoring component 408 combines individual relationship probabilities to generate an overall confidence score for each pattern. These scores can be used to validate patterns before applying them to expand the knowledge graph.

[0083] Component 410 modifies the knowledge graph data structure based on validation patterns. In some examples, and referencing... Figure 3 The graph adjustment component 410 incorporates linear patterns into the ontology data structure 304 by adding new rules or constraints. For circular patterns, the graph adjustment component 410 identifies incomplete patterns in the knowledge graph data structure 302 and generates a triple data structure 320 to complete or extend the assertion data structure 306, while maintaining consistency with the patterns. In some examples, the pattern application component 412 automatically adjusts the knowledge graph when the confidence score of a particular pattern exceeds a threshold.

[0084] Pattern application component 412 implements patterns to continuously expand the knowledge graph data structure. For example, when new data is added to the knowledge graph data structure 302, pattern application component 412 applies existing patterns (e.g., validated patterns) to ensure the knowledge graph is continuously expanded. In some examples, pattern application component 412 automatically applies patterns when a pattern's confidence score exceeds a configured threshold.

[0085] The threshold configuration component 414 manages the thresholds used during pattern detection and validation. In some examples, the threshold configuration component 414 adjusts the occurrence threshold based on the inheritance depth of class nodes to account for pattern generality at different levels, for example, such as... Figure 8 As shown. The threshold configuration component 414 can also configure the confidence threshold, specifying whether the confidence threshold determination mode is automatically incorporated or requires manual verification, such as... Figures 21 to 23 The user interface example referenced in the document.

[0086] User interface component 416 enables user 208 to interact with knowledge graph system 232 in an effective manner. For example, user interface component 416 implements the configuration of knowledge graph system 232 and interaction with detected patterns. In some examples, user interface component 416 presents detected patterns sorted by confidence scores and allows the user to manually verify the patterns before applying them. User interface component 416 can display pattern details, including the triples involved, frequency of occurrence, and examples of matching instances. One or more interfaces allow the user to configure processing parameters such as thresholds and class selection.

[0087] Figure 5 It is a graphical representation of knowledge graph patterns based on some examples. Figure 5 A portion of a knowledge graph 500 with example schema 502 is shown, illustrating the relationships between companies, people, and their associated attributes.

[0088] Two structures in knowledge graph 500 are shown in parallel to illustrate how pattern 502 is determined to be repeated within knowledge graph 500. The first structure includes person A (node ​​504) working at company A (node ​​508). Person A (node ​​504) is the inventor of a patent entitled "Method and System for Language Processing" (node ​​512) related to "machine learning" (node ​​510). Company A (node ​​508) researches "machine learning" (node ​​510), demonstrating the relationship between the company's research interests and the patent listing an employee as an inventor.

[0089] The second parallel structure illustrates Person B (Node 514) working at Company B (Node 518). Person B (Node 514) is the inventor of the patent "Method and System for Ranking Search Results" (Node 522) related to "Search Engine" (Node 520). Company B (Node 518) researches "Search Engine" (Node 520), illustrating a similar pattern to the relationship between a company's research areas and patents involving its employees.

[0090] Pattern 502 is surrounded by dashed lines to indicate that it represents a detected repeating pattern in knowledge graph 500. EmilySmith (node ​​506) and John Doe (node ​​516) represent the specific instance names associated with person A and person B, respectively. This disclosure describes examples illustrating how knowledge graph system 232 can detect such patterns (including from complex data structures), thereby making it easier to infer new relationships or verify existing relationships in the knowledge graph.

[0091] Figure 6 This is a flowchart illustrating the operation of method 600 for pattern detection and application in knowledge graphs, based on some examples. See also: Figure 2 Components of the knowledge graph system 232 and Figure 3 The knowledge graph data structure 302 is used to describe the operations. Although method 600 describes a specific order of operations, this order can be changed without departing from the scope of this disclosure. For example, some of the described operations can be performed in parallel or in a different order that does not substantially affect the functionality of method 600. In some examples, different components of the knowledge graph system 232 can perform functions substantially simultaneously or in a specific order.

[0092] Method 600 begins at open-loop element 602. At operation 604, the data access component 402 of the knowledge graph system 232 receives user instructions that may include configuration parameters such as occurrence thresholds and class selection. Note that configuration parameters may be user-provided, system-level set, or a combination thereof.

[0093] At operation 606, data access component 402 accesses a knowledge graph data structure, such as knowledge graph data structure 302. At operation 608, preprocessing component 404 preprocesses the knowledge graph data structure to generate a modified knowledge graph data structure. In some examples, preprocessing may include replacing instance nodes in the knowledge graph with class nodes, materializing implicit statements, and adding inverse relations of attributes. In some examples, knowledge graph system 232 operates on a copy of the input graph for pattern detection and then begins preprocessing the copy.

[0094] In some examples, preprocessing component 404 materializes all implicit statements by leveraging the inferencer and adds them to the graph. After replacing the instance nodes with their corresponding classes, preprocessing component 404 then adds a reverse to each property that does not have a reverse property and adds these additional triples to the graph for better traversal during pattern detection.

[0095] At operation 610, pattern detection component 406 performs recursive pattern detection. The pattern detection process may involve initiating paths from one or more starting class nodes and expanding each path individually based on attribute-class combinations that exceed a configured occurrence threshold. For each starting class node, recursive processing continues until a stopping condition for that particular path is met, such as detecting a circular pattern, reaching the maximum number of iterations, or determining that no attribute-class combination exceeds the threshold of the current node in that path.

[0096] The knowledge graph system 232 can measure the relative frequency with respect to an occurrence threshold to determine whether attribute-class combinations should be included in a pattern. For example, if the "Painting" class has 100 instances, and 80 of them have a "hasPainter" relationship with the "Painter" class, the relative frequency would be 0.8 (80%). If the configured threshold is 0.75, the relationship would exceed the threshold and be included. This method ensures that the knowledge graph system 232 identifies meaningful patterns regardless of the absolute number of instances in different parts of the knowledge graph data structure.

[0097] At operation 612, the confidence scoring component 408 generates a confidence score for the detected pattern by calculating the probability of relationships within the pattern and combining these probabilities. At operation 614, the confidence scoring component 408 validates the pattern based on their confidence scores. In some examples, the pattern can be automatically validated when its confidence score exceeds a configured threshold, where different thresholds are potentially applied based on the inheritance depth of the class nodes involved in each path, such as... Figure 8 As shown.

[0098] At operation 616, the graph adjustment component 410 adjusts the knowledge graph data structure 302 based on the verified patterns, and the pattern application component 412 applies patterns to expand the information provided by the knowledge graph. For example, for linear patterns, these components add rules to the ontology data structure 304. For circular patterns, they identify incomplete patterns in the knowledge graph data structure 302 and generate a triplet data structure 320 to complete them. In other words, the knowledge graph system 232 can therefore add detected patterns to the T-Box of the relevant knowledge graph, complete or expand the A-Box of the graph based on the detected patterns, or both.

[0099] At operation 618, the user interface component 416 outputs results, which may include displaying detected patterns, confidence scores, and newly added relationships. A suitable interface allows users to view and potentially modify detected patterns before applying them to the knowledge graph data structure 302. Method 600 ends at operation 620.

[0100] The following provides a more detailed, non-limiting example of operation 610 of method 600 to illustrate certain aspects of pattern detection. In this example, the pattern detection process begins by accessing a preprocessed knowledge graph, where instance nodes have been replaced with their corresponding class nodes and inverse relationships have been added. For the specific class in question, knowledge graph system 232 initiates pattern detection from a configured starting class node, which can be selected by user input specifying the class of interest from the available class nodes in the graph.

[0101] Starting from the initial class node, the knowledge graph system 232 analyzes all possible attribute-class combinations emanating from that node. For each attribute-class combination, the knowledge graph system 232 calculates the occurrence frequency by determining how often a particular attribute is connected to instances of the target class on the knowledge graph. As described above, this can be represented as a relative frequency. The knowledge graph system 232 then compares each calculated frequency with a configured occurrence threshold, which can be dynamically selected based on the inheritance depth of the class nodes involved in the relation.

[0102] When the frequency of an attribute-class combination exceeds a threshold, the knowledge graph system 232 expands the current path by adding that combination and sets the target class node as the new current node for the next iteration. This process continues recursively, with each iteration analyzing attribute-class combinations from the current node and using combinations that exceed the threshold to expand the path.

[0103] The recursive path expansion process can include validation checks at each step. For example, the knowledge graph system 232 keeps track of visited nodes and relationships to detect when a path forms a circular pattern. Furthermore, the knowledge graph system 232 monitors the iteration count against a configured maximum value to prevent infinite recursion and continuously evaluates whether any attribute-class combination from the current node exceeds an occurrence threshold.

[0104] During pattern detection, the knowledge graph system 232 also processes implicit relations concretized during preprocessing. These relations, derived from the ontology structure, are considered along with explicit relations when calculating frequency of occurrence and extension paths. The knowledge graph system 232 processes direct relations and their inverse correspondences added during preprocessing, thereby ensuring comprehensive pattern detection in both directions through the graph.

[0105] Once the stopping conditions are met, the system finalizes the patterns and prepares them for verification and potential incorporation into the knowledge graph structure. In some examples, when a pattern is detected, the knowledge graph system 232 calculates a confidence score by determining the probability of each relation within the pattern and combining these probabilities. These scores are used to rank the patterns and determine whether they can be automatically incorporated into the knowledge graph structure or require manual verification.

[0106] As an example, for a path ( The detected patterns are defined as follows: v represents a vertex (node), e represents an edge (relation). The knowledge graph system 232 calculates the probability of the entire path by multiplying the probabilities of each relation segment. Therefore, the path probability can be expressed as: Each component probability represents the frequency of that specific relation in the knowledge graph.

[0107] Knowledge graph system 232 can use these calculated confidence scores to determine how patterns should be processed. In some examples, knowledge graph system 232 implements a configurable threshold method for managing pattern validation and application. When a pattern's confidence score exceeds a configured threshold (where the threshold ∈ (0,1)), the pattern can be automatically approved without manual review. Conversely, patterns with confidence scores below the threshold are presented to the user for manual validation.

[0108] The threshold configuration component 414 allows for flexible management strategies regarding pattern validation. Setting the threshold to 1.0 ensures that all patterns require manual review, regardless of their confidence scores, thus providing maximum supervision for knowledge graph modifications. Alternatively, setting the threshold to 0.0 enables fully automated pattern approval, allowing the knowledge graph system 232 to merge all detected patterns without human intervention.

[0109] The pattern detection process performed by the knowledge graph system 232 can leverage parallel processing capabilities to efficiently analyze and detect patterns on the knowledge graph structure. In some examples, multiple starting class nodes can be processed simultaneously, where each node potentially initiates its own pattern detection path through the graph.

[0110] The system can maintain multiple active paths from each starting node. When the attribute-class combination exceeds an occurrence threshold, the system can explore multiple branch paths. This multi-path exploration allows for the discovery of different pattern structures within the same region of the graph.

[0111] In some implementations, the architecture of the knowledge graph system 232 can support concurrent pattern verification and scoring across multiple detected patterns. Parallel processing can be extended to pattern applications. Once a pattern is verified, the knowledge graph system 232 can simultaneously incorporate multiple patterns into the knowledge graph structure.

[0112] A code snippet of an example pattern detection algorithm is shown, followed by a discussion below. Note that during the operation of the knowledge graph system 232, this algorithm can be applied to only one class or to multiple classes.

[0113] #We examine the optional parameter C of the class we are interested in.

[0114] IF isEmpty(C) THEN

[0115] C = G.getAllClasses()

[0116] result_patterns = new Set()

[0117] FOR EACH c IN C DO:

[0118] # t is the threshold, and i is the maximum number of iterations.

[0119] # Note that this collection should avoid adding duplicates.

[0120] # current_it is the current iteration depth (starting from 0).

[0121] # g is the working graph

[0122] Paths = new Set()

[0123] Paths.add(c)

[0124] result_patterns.addAll(

[0125] runPatternDetection(Paths, t, i, current_it = 0, g)

[0126] METHOD runPatternDetection(Paths, t, i, current_i, g)

[0127] wasPathAdded = false

[0128] FOR EACH path IN Paths DO

[0129] IF isCircle(path) THEN

[0130] CONTINUE

[0131] FOR EACH property IN g.getProperties() DO

[0132] FOR EACH class IN g.getClasses() DO

[0133] occurrence = count_all_occurrences(path.getLastClass(), property, class)

[0134] relative = occurrence / count_all(path.getLastClass())

[0135] # t is the relative threshold

[0136] IF relative < t THEN

[0137] g.removeAllTriples(subject=c, predicate=property,object=class)

[0138] ELSE:

[0139] path.add(property, class)

[0140] wasPathAdded = true

[0141] current_i = current_i + 1

[0142] IF current_i = i OR wasPathAdded == false:

[0143] RETURN Paths

[0144] ELSE:

[0145] RETURN runPatternDetection(Paths=Paths, t=t, i=i, current_i=current_i, g=g))

[0146] Based on some examples, the code above implements a pattern detection algorithm for analyzing and processing knowledge graph structures. The algorithm begins by examining an optional parameter C that specifies the classes of interest. If C is empty, it retrieves all classes from the graph G using getAllClasses(). This initialization ensures that the algorithm can process specific classes or the entire graph structure.

[0147] The main processing loop iterates through each class c in the set of classes C. For each class, it initializes a new Set called Paths, starting from the current class c. The algorithm then calls runPatternDetection with several parameters: the set of Paths, the threshold t, the maximum iteration i, the current iteration depth (starting from 0), and the working graph g. Note that the working graph can be a copy of the graph structure, as discussed elsewhere in this paper.

[0148] The `runPatternDetection` method implements the pattern detection logic. For each path, it first checks if the path forms a circle using `isCircle(path)`. This implements the stopping condition for detecting circular patterns. Then, the method checks each attribute-class combination by traversing all relevant attributes and classes in the graph. For each combination, it calculates the absolute occurrence count and relative frequency.

[0149] A threshold checking mechanism is illustrated: if the relative frequency is below a threshold t (which can be set to different values, for example, adjusted depending on the inheritance depth of one or more classes being analyzed in a particular iteration), those triples are removed from the graph. Otherwise, attribute-class combinations are added to the path, and the wasPathAdded flag is set to true. This implements a method for expanding paths with attribute-class combinations that exceed the occurrence threshold.

[0150] The recursive nature of the algorithm is handled by the last part of the example shown, where it returns the current Paths (if the maximum iteration i is reached or no new path is added) or makes a recursive call to continue pattern detection. This recursive expansion continues until an appropriate stopping condition is met. The algorithm keeps track of the iteration depth using the current_i parameter and uses the wasPathAdded flag to determine if further processing is needed.

[0151] As described above, the pattern detection process can identify two different types of patterns: linear patterns and circular patterns. For linear patterns, the knowledge graph system 232 focuses on sequences of relations that consistently appear together. For circular patterns, the knowledge graph system 232 identifies loops in relation chains that imply implicit relationships between entities.

[0152] Knowledge graph system 232 distinguishes between these two pattern types based on their structure and application. Linear patterns, such as “A-has->B-isOf->C” (e.g., “A car has tires made of rubber”), represent ontology patterns that can potentially be added to ontology data structure 304 to expand the pattern. These linear patterns make the facts explicit but do not necessarily lead to the generation of new instance-level triples. Circular patterns, such as “A–lives_in->B–was_drawn->C–drawn_by->A” (e.g., “Artist A lives in city C where artist A draws picture P”), form loops in the relation chain. These loops can be used to complete similar but incomplete patterns found elsewhere in the graph by generating new triple data structure 320, thus enabling automatic completion of the knowledge graph.

[0153] Figure 7 This is a graphical representation of a ring pattern 700 based on some examples. Figure 7 An example is shown within a knowledge graph structure that illustrates relationships between artistic entities. The pattern illustrates three interconnected nodes linked by directional edges representing specific relationships: "HAS PAINTER" connecting the first node to the second, "HAS STYLE" connecting both the first and second nodes to the third, and a reverse "HAS STYLE" relationship completing the loop back to the first node. This circular structure represents a common pattern where painting, painter, and art style are interconnected through consistent relationships.

[0154] The detected circular patterns illustrate how the knowledge graph system 232 can use certain recurring relational structures within the knowledge graph. When such patterns are detected with sufficient frequency of occurrence and confidence scores, they can be used to extend the assertion data structure of the knowledge graph by generating new triplet data structures that complete similar but incomplete patterns found elsewhere in the graph.

[0155] In some examples, and unlike geometric rings, the circular patterns detected in the knowledge graph have different starting and ending points, which enables directional reasoning about relations. For example, in pattern 700, while inferring the art style of a painting from the style associated with its painter might be logically valid, reverse inference (determining the artist of the painting solely based on matching art styles) might be unreasonable or invalid. This directionality in circular patterns allows the knowledge graph system 232 to maintain logical consistency when applying patterns used for knowledge graph completion. The same circular structure can be analyzed from multiple entry points, thus achieving different valid inference paths through the same set of relations, while still preserving the logical constraint of making reasonable inferences based on the directionality of relations.

[0156] Figure 8 This is a graphical representation of an inheritance tree 800 based on some examples. Inheritance tree 800 demonstrates how the threshold t used in pattern detection can be dynamically adjusted based on the inheritance depth within the knowledge graph.

[0157] exist Figure 8 In the inheritance tree 800, different thresholds can be applied at different inheritance levels, where t=A at the highest level, t=B at the middle level, and t=C at the lowest level. This adjustment of the thresholds can reflect a general approach to handling variations within the inheritance hierarchy.

[0158] In some implementations, a constraint factor L can be used to modify the threshold t, where, when the knowledge graph system 232 traverses the knowledge graph (e.g., constrained by a maximum t value), the new threshold (t_new) can be equal to L multiplied by the old threshold (t_old). For example, moving from the lowest level node, the new threshold for the new level node can be calculated as t_new = L. t_old, and the constraint factor L used to determine the new threshold can be calculated based on the maximum depth of the inheritance tree 800 and the distance to the highest level, using a formula such as L = 1 + (1 – 0.5^(max_depth-distance_to_highest_level)), where t_new = MIN(t_old) L, 1). Therefore, in some examples, and using the three levels of the inheritance tree 800 to illustrate, the knowledge graph system 232 can implement an adjustable threshold so that higher inheritance levels (e.g., levels A or B relative to level C) have a higher threshold applied to them.

[0159] Applying stricter thresholds to higher, more general levels (e.g., the top level in a “penalty” hierarchy) can help manage the risk associated with broader statements that affect many triples in the knowledge graph, as these general statements may be more likely to be incorrect. However, the threshold t can be adjusted or changed in many ways, and the aforementioned limiting factor L is merely an example.

[0160] Figures 9 to 20 The progressive stages of pattern analysis and detection in knowledge graph data structures, based on several examples, are visualized. Figures 9 to 20In the data visualization, letters represent class nodes, and numbered edges represent different attribute types between class nodes. These graphs illustrate progressive steps of processing, for example, performed by knowledge graph system 232. Initially, knowledge graph system 232 begins with a complex interconnected graph structure, where nodes (labeled A, B, C, and D) are connected by edges (numbered 1, 2, 3, 4, and 5) representing different relationships. The process operates by analyzing the frequency of connections between specific nodes, where solid lines represent direct relationships and dashed lines indicate inverse relationships that can be added during preprocessing.

[0161] As visualization is performed via accompanying figures, it is shown that the knowledge graph system 232 recursively evaluates the paths between nodes based on an occurrence threshold, gradually identifying and highlighting statistically significant patterns while removing or ignoring less relevant connections. The process ends with the discovery of patterns that meet the configuration criteria. Therefore, Figures 9 to 20 An example of the runPatternDetection algorithm described above is visualized. Note that this is for illustrative purposes only. Figures 9 to 20 This only illustrates the detection of a pattern from a single starting class node (in this case, class A selected from class A to D). The knowledge graph system 232 can operate to repeat a similar process for various classes and can detect multiple different patterns in this way.

[0162] Now, let's refer more specifically to data visualization. Figure 9 The data visualization 900 is shown, illustrating the first stage. The visualization displays the knowledge graph after instance nodes have been replaced by their corresponding class nodes (labeled A, B, C, and D). Numbered edges between nodes represent different attribute types.

[0163] Figure 10 Further data visualization 1000 for the pattern detection process is shown, illustrating subsequent stages. Figure 10 The preprocessing is illustrated, where the knowledge graph system 232 adds a corresponding reverse relation (shown as a line with a solid number) in the opposite direction for each existing relation (shown as a line with a solid number 4 connecting one node to another). For example, in the case where a solid line with the number 4 connects one node to another, a dashed line with the number 4 has already been added in the opposite direction to indicate the reverse attribute. In other words, the knowledge graph system 232 adds a "reverse relation" corresponding to "relation 4". For example, this could be related to... Figure 7 The "HASSTYLE" relation shown corresponds to the inverse "HAS STYLE" relation.

[0164] As an illustrative example, a user (e.g., user 208) has selected class A (e.g., via a method such as...). Figure 2 The web interface 228 is the user interface. Figure 11Further data visualization 1100 for the pattern detection process is shown, illustrating all nodes of detection class A in the knowledge graph system 232 (e.g., ...). Figure 11 (as shown by the dashed line in the diagram) is a further stage.

[0165] The knowledge graph system 232 will begin analyzing the relationships extending from these user-selected starting nodes, considering both direct and inverse relationships to identify potential patterns. For example, in... Figure 12 Further data visualization in 1200, depicted by labels A1 to A6, shows six class A nodes that, based on the user's class selection, will thus be used as the initial starting class node from which the recursive pattern detection will begin.

[0166] Knowledge graph system 232 calculates the occurrences associated with category A. Specifically, in this example, knowledge graph system 232 evaluates attribute-class combinations extending from nodes A1 to A6 by calculating the frequency of occurrence of edge combinations with different numbers. Knowledge graph system 232 determines which combinations exceed a configured threshold to identify statistically significant patterns.

[0167] Note that, primarily for simplicity, absolute numbers are calculated rather than relative numbers in this example. This is based on the assumption that the graph contains an equal distribution of class numbers.

[0168] In this example, the knowledge graph system 232 first detects that the following edges are statistically significant when viewing from nodes A1 to A6:

[0169] ● Edge number 4 extends from 5 out of 6 nodes A1 to A6; and

[0170] ● The edge number 5 extends from 3 out of 6 nodes A1 to A6 in reverse order.

[0171] In such Figure 13 In the further data visualization 1300 shown, the outgoing edges of focus nodes below the threshold are not shown. Furthermore, in Figure 14 The further data visualization 1400 shown visualizes the correlation detections related to edge number 4 and edge number reverse 5 (e.g., 4-1, 4-2, 4-3, 5-1, 5-2, etc.).

[0172] The knowledge graph system 232 examined the related attribute-class combinations associated with edge number 4 and edge number inverse 5, and detected the following:

[0173] ● Edge number 4 extends from 3 out of 6 nodes A1 to A6 to class D; and

[0174] ● The edge number 5 is extended in reverse from 3 out of 6 nodes A1 to A6 to class B.

[0175] In other words, for 50% of nodes A1 to A6, there exists an attribute-class combination 4-D that creates a possible path from AD, and for the same 50%, there exists an attribute-class combination 5-B that creates a possible path from AB. Assuming a threshold of 3 (e.g., the current class node requires at least 3 identical attribute-class combinations), the knowledge graph system 232 determines which combinations to use to expand the path. All other attribute-class combinations associated with nodes A1 to A6 do not satisfy threshold 3 and are therefore ignored by the knowledge graph system 232 at this stage.

[0176] like Figure 15 Further data visualization 1500 shows that the knowledge graph system 232 then proceeds recursively, treating classes B and D (as shown by dashed lines) as new starting class nodes for expanding paths. In other words, Figure 15 The dashed loop in the diagram highlights the new focal node at the end of the current path, specifically class node B connected to A via reverse relation 5 and class node D connected to A via relation 4. These highlighted nodes represent the next node to be processed in the recursive pattern detection algorithm.

[0177] Figure 16 Further data visualization 1600 is shown, highlighting unreachable nodes from class A. These nodes are shown in box 1602. Nodes that are unreachable based on threshold criteria (and their connecting edges) have been identified. Figure 17 Further data visualization in 1700 shows the removal of unqualified nodes, reflecting the implicit filtering that occurs in the algorithm through thresholding and removal steps. For clarity, this removal of unqualified nodes is visualized here, showing how the pattern detection algorithm progressively focuses only on the statistically significant parts of the graph.

[0178] As in Figure 18 Further data visualization in 1800 is described by labels D1, D2, D3, B4, B5, and B6. The knowledge graph system 232 sets a new current class node and calculates the occurrence and inspection thresholds from the new current class node in the manner described above for nodes A1 to A6.

[0179] Knowledge graph system 232 detected the following for class D:

[0180] ● Edge number 1 extends from all 3 D nodes D1, D2, and D3 to class C; and

[0181] ● The edge number 4 extends from all 3 D nodes D1, D2, and D3 to class A.

[0182] Knowledge graph system 232 detected the following content for class B:

[0183] ● Edge number reversed 3 extends from all 3 B nodes B4, B5, and B6 to class C; and

[0184] ● Edge number 5 extends from all 3 B nodes B4, B5, and B6 to class A.

[0185] These statistically significant connections are preserved, extending the path to class C, while the knowledge graph system 232 removes all nodes unreachable from the currently focused node (via edges exceeding a threshold). Figure 19 Further data visualizations are depicted in 1900, and loop 1902 is unreachable and therefore not considered further.

[0186] Therefore, the pattern detection process essentially follows a geometric approach to progressively eliminate parts of the graph that do not participate in statistically significant patterns. The algorithm stops running once a stopping condition is met. In this example, the algorithm stops after N hops (e.g., a predetermined number of iterations, such as 4, 6, or 10) or once all nodes are part of a pattern (or a confirmed path) or have been removed.

[0187] The rest is as follows Figure 20 The final data visualization 2000 shows pattern 2002, where no other nodes exist, thus triggering the algorithm to stop. The visualization shows that the system has detected a pattern 2002 that repeats three times, representing the final validated pattern extracted from the graph structure. In this example, pattern 2002 is circular and includes classes A, B, C, and D. However, as discussed elsewhere in this paper, linear patterns can also be detected. Pattern 2002 illustrates the relationship between class nodes and their connectivity attributes, forming statistically significant patterns based on their frequency of occurrence exceeding a configured threshold, representing the output of a pattern detection process that can be used for knowledge graph expansion.

[0188] Figure 21 This is a user interface block diagram illustrating a user interface 2100 for configuring pattern detection operations, based on some examples. The user interface 2100 includes category information 2102, which displays a table of categories detected in a specific knowledge graph selected by the user (see [link to documentation]). Figure 21 (File path in the file). Class information 2102 includes checkboxes for selecting which classes to include in the calculation and pattern detection. For each class (e.g., "PAINTING"), the user can independently choose whether to include the class in the calculation and whether to find a pattern for that class.

[0189] By excluding certain classes, users can essentially make the knowledge graph system 232 evaluate only a portion of a larger knowledge graph. However, for the purposes of this disclosure, such a portion is still considered a knowledge graph data structure from which one or more patterns are detected.

[0190] User interface 2100 also includes calculation options with several configurable parameters. The occurrence threshold 2104 field allows setting a threshold (shown as 0.4), while iteration setting 2106 enables specifying an iteration limit (shown as 5). User interface 2100 also includes approval setting 2108, which has a toggle key for enabling automatic approval and an automatic approval threshold 2110 (shown as 0.75). This sets a threshold against which the knowledge graph system 232 evaluates the confidence score of detected patterns.

[0191] At the bottom of the user interface 2100, the Calculate button 2112 initiates the pattern detection process. Additional checkboxes at the bottom allow the user to optionally include all classes in the calculation or use all classes for pattern detection.

[0192] Figure 22 This is a user interface block diagram illustrating a user interface 2200 for displaying and managing detected patterns, based on some examples. The user interface 2200 includes pattern information 2202, which displays a table of detected patterns along with their characteristics and approval status. For each pattern, the table in pattern information 2202 shows whether it forms a loop, its probability score, and whether it has been approved. Patterns are sorted by probability, "Painting -> Painter -> Art Style -> Painting," with the highest probability pattern (0.80 probability) appearing at the top.

[0193] User interface 2200 includes selected pattern details 2204, which provides detailed information about the selected pattern, including the triplet data structure involved, the frequency of occurrence in the knowledge graph, the probability score, and examples of patterns in the knowledge graph. Figure 22 In the example shown, the user has selected the highest probability mode, so its details are shown as Selected Mode Details 2204.

[0194] The Remove Approval button 2206 allows users to revoke approval of previously or automatically approved modes. The user interface 2200 also displays an automatic approval threshold 2110 (shown as 0.75) for determining which modes can be automatically approved.

[0195] Figure 23 This is a user interface block diagram illustrating another user interface 2300 for displaying and managing detected patterns, based on some examples. User interface 2300 includes... Figure 22 The same pattern information 2202 is shown, displaying a table of detected patterns, their characteristics, and approval status. The user interface 2300 also displays selected pattern details 2204 with information about the selected pattern, including the triples involved, the number of occurrences, and the probability score.

[0196] The difference between user interface 2300 and user interface 2200 is the addition of an apply button 2302, which replaces the remove approval button in user interface 2200. The apply button 2302 allows the user to actively implement the selected mode.

[0197] Figure 24 This is a user interface block diagram illustrating a user interface 2400 for editing and adding detected patterns, based on some examples. The user interface 2400 visualizes a circular pattern 2402, which shows the relationships between nodes connected by oriented edges labeled with attributes. Circular pattern 2402 and... Figure 7 The same as the ring pattern 700. The edit pattern button 2404 allows the user to modify the detected pattern structure.

[0198] User interface 2400 further displays pattern details 2406, which shows comprehensive information about the selected pattern, including the triples involved in forming the pattern. An add button 2408 allows the user to add new facts to the knowledge graph based on the detected pattern. To this end, user interface 2400 displays new facts 2410 that can be derived from the applied pattern, allowing the user to view and confirm the addition before adding it to the knowledge graph. Therefore, user interface 2400 provides granular control over pattern editing and application while maintaining a clear visualization of the pattern structure and its meaning to the knowledge graph.

[0199] The examples in this disclosure can be useful in various technical contexts. As a first example scenario, in the context of knowledge graph maintenance, the pattern detection and completion system described herein can provide technical advantages for graph quality management. For example, the system enables the automatic identification of missing facts in a knowledge graph based on detected patterns, thereby eliminating the need for tedious analysis to identify information gaps. By preprocessing the knowledge graph data structure and applying a recursive pattern detection algorithm, the system effectively analyzes relationships between entities to identify repeating patterns that suggest locations where information may be missing. A confidence scoring mechanism automatically ranks detected patterns based on statistical significance, allowing knowledge graph administrators to prioritize high-confidence patterns for graph completion. This approach reduces the computational complexity of analyzing large amounts of graph data by operating on compressed class-level representations rather than processing all instance-level relationships. Furthermore, configurable thresholds allow graph administrators to balance automation with supervision, automatically adding high-confidence facts while maintaining a view to less certain cases, thus significantly improving the efficiency and accuracy of knowledge graph maintenance compared to error-prone manual methods.

[0200] As a second example scenario, in a customer service technology environment, knowledge graph pattern detection systems offer technological advantages for escalation management. For instance, the system enables the automatic identification of recurring patterns related to escalation in customer complaint data, eliminating the need for time-consuming manual analysis. The system can effectively analyze complex relationships between ticket attributes, customer interactions, and resolution paths that human analysts might miss when manually sifting through large amounts of data. A confidence scoring mechanism automatically ranks detected patterns based on statistical significance, allowing support teams to prioritize tickets matching high-confidence escalation patterns. This approach reduces the computational complexity of analyzing large amounts of customer service data by operating on compressed class-level representations rather than processing all instance-level relationships. The ability to detect linear patterns (e.g., for expanding the ontology with new escalation indicators) and circular patterns (e.g., for completing missing information in ticket data) provides comprehensive support for escalation prediction.

[0201] As a third example scenario, within the context of financial risk management technology, knowledge graph pattern detection systems can offer technological advantages for identifying potential risks in investment portfolios. The system can automatically detect recurring patterns in financial instrument data that may indicate market risk, eliminating the need for time-consuming analysis of complex financial relationships. It effectively analyzes relationships between financial instruments, markets, products, and competitors—relationships that human analysts might miss when manually examining large amounts of financial data. A confidence scoring mechanism automatically ranks detected patterns based on statistical significance, allowing risk analysts to prioritize high-confidence risk patterns in specific financial instruments or market segments. This reduces the computational complexity of analyzing large amounts of financial data by operating on compressed class-level representations rather than processing all instance-level relationships. The ability to detect linear patterns (e.g., for expanding ontologies with new risk metrics) and circular patterns (e.g., for completing missing information in financial instrument data) provides comprehensive support for risk identification.

[0202] As a fourth example scenario, in the context of human resources (HR) technology, knowledge graph pattern detection systems can offer technological advantages to employee management systems. The system enables the automatic identification of recurring patterns in employee data that are related to high performance, eliminating the need for time-consuming analysis of complex employee relationships. It effectively analyzes relationships between employees, their skills, experience, roles, and career paths—relationships that human analysts might miss when manually reviewing large amounts of HR data. A confidence scoring mechanism automatically ranks detected patterns based on statistical significance, allowing HR managers to prioritize high-confidence performance indicators across all employees. This approach reduces the computational complexity of analyzing large amounts of employee data by operating on compressed class-level representations rather than processing all instance-level relationships. The ability to detect linear patterns (e.g., for expanding ontologies with new performance indicators) and circular patterns (e.g., for completing missing information in employee profiles) provides comprehensive support for talent optimization. Furthermore, geometric analysis methods generate inherently human-interpretable patterns because they represent clear chains of relationships between entities rather than black-box predictions, enabling HR managers to interpret performance evaluations based on concrete, observable patterns in the data.

[0203] In view of the above-described embodiments of the subject matter, this application discloses the following list of examples, wherein a feature of a single example or a combination of one or more features of one or more other examples, and optionally more than one feature of an example combined with one or more features of one or more other examples, are other examples that also fall within the disclosure of this application.

[0204] Example 1: A system including at least one memory storing instructions and one or more processors, configured to perform operations when the instructions are executed, the operations including: accessing a knowledge graph data structure stored in a data store; preprocessing the knowledge graph data structure by replacing instance nodes with class nodes to generate a modified knowledge graph data structure; automatically detecting patterns by processing the modified knowledge graph data structure, including initiating a path from a starting class node in the modified knowledge graph data structure and recursively expanding the path until a stopping condition is met, wherein attribute-class combinations from current class nodes in the path have an occurrence frequency exceeding an occurrence threshold; and adjusting the knowledge graph data structure stored in the data store based on the patterns.

[0205] Example 2: In the topic of Example 1, the preprocessing of the knowledge graph data structure also includes adding the triple data structure to the knowledge graph data structure by concretizing the implicit statements based on the ontology data structure of the knowledge graph data structure.

[0206] Example 3: In the topic of Example 1, the preprocessing of the knowledge graph data structure also includes adding inverse relations to one or more attributes in the knowledge graph data structure.

[0207] Example 4: In the topics of Examples 1 to 3, where the attribute-class combination is a specific attribute-class combination among multiple attribute-class combinations from the current class node, the operations include: determining the frequency of occurrence of each of the multiple attribute-class combinations; determining that the frequency of occurrence of the specific attribute-class combination exceeds an occurrence threshold; and in response to determining that the frequency of occurrence of the specific attribute-class combination exceeds the occurrence threshold: extending the path using the specific attribute-class combination; and setting the target class node of the specific attribute-class combination as the current class node.

[0208] Example 5: In the topics of Examples 1 through 4, the stopping condition includes at least one of the following: a path is detected to form a circular pattern; the maximum number of iterations is reached; or no attribute-class combination from the current class node is detected whose occurrence frequency exceeds the occurrence threshold.

[0209] Example 6: In the topics of Examples 1 through 5, the operation also includes, before adjusting the knowledge graph data structure stored in the data store: generating a confidence score for the pattern by determining the probability of relations within the pattern and combining the determined probabilities; and validating the pattern based on the confidence score.

[0210] Example 7: In the topics of Examples 1 through 6, adjusting the knowledge graph data structure includes: detecting that the confidence score generated for the pattern exceeds a confidence threshold; and in response to detecting that the confidence score exceeds the confidence threshold, automatically merging the pattern into the ontology data structure of the knowledge graph data structure.

[0211] Example 8: In the subject of Examples 1 through 7, the operation further includes, before adjusting the knowledge graph data structure stored in the data store: generating confidence scores for patterns; presenting information identifying multiple detected patterns in a user interface on a user device, the multiple detected patterns including the pattern and one or more further patterns detected from the modified knowledge graph data structure, wherein the multiple detected patterns are ordered based on their respective confidence scores; and receiving user input to verify the patterns.

[0212] Example 9: In the topics of Examples 1 through 8, adjusting the knowledge graph data structure includes at least one of the following: merging schemas into the ontology data structure of the knowledge graph data structure; or updating the assertion data structure of the knowledge graph data structure based on schemas.

[0213] Example 10: In the topic of Example 9, wherein adjusting the knowledge graph data structure includes updating the assertion data structure, and updating the assertion data structure includes: detecting at least one incomplete pattern in the knowledge graph data structure that matches a pattern detected using the modified knowledge graph data structure; generating one or more triple data structures to complete at least one incomplete pattern; and adding one or more triple data structures to the assertion data structure.

[0214] Example 11: In the subject of Example 10, it also includes: presenting information identifying one or more triplet data structures in a user interface on a user device; and receiving user input for selecting one or more triplet data structures, wherein, in response to receiving the user input, one or more triplet data structures are added to an assertion data structure.

[0215] Example 12: In the topics of Examples 1 through 11, the patterns include: linear patterns, which are applied to the ontology data structure of the knowledge graph data structure after the pattern is detected; or circular patterns, which are applied to the assertion data structure of the knowledge graph data structure after the pattern is detected.

[0216] Example 13: In the subject of Examples 1 to 12, the operation further includes: causing information identifying multiple classes associated with class nodes to be presented in a user interface on a user device; receiving user input to select a class of interest from the multiple classes; and, in response to receiving user input to select a class of interest, configuring the processing of a modified knowledge graph data structure such that the class of interest is the starting class node.

[0217] Example 14: In the topics of Examples 1 through 13, a threshold is selected based on the inheritance depth of one or more class nodes in a class node.

[0218] Example 15: A computer-implemented method performed by a computer system including memory and at least one hardware processor, performing the operations of Example 1.

[0219] Example 16: In the topic of Example 15, the preprocessing of the knowledge graph data structure also includes adding the triple data structure to the knowledge graph data structure by concretizing the implicit statements based on the ontology data structure of the knowledge graph data structure.

[0220] Example 17: In the topic of Example 15, the preprocessing of the knowledge graph data structure also includes adding inverse relations to one or more attributes in the knowledge graph data structure.

[0221] Example 18: One or more non-transitory computer-readable media storing computer-executable instructions that, when executed by a computing system, cause the computing system to perform the operations of Example 1.

[0222] Example 19: In the topic of Example 18, the preprocessing of the knowledge graph data structure also includes adding a triplet data structure to the knowledge graph data structure by concretizing implicit statements based on the ontology data structure of the knowledge graph data structure.

[0223] Example 20: In the topic of Example 18, the preprocessing of the knowledge graph data structure also includes adding inverse relations to one or more attributes in the knowledge graph data structure.

[0224] Example 21: An apparatus comprising means for performing one or more elements of a method described or associated with any of the foregoing examples or any other method or process described herein.

[0225] Example 22: One or more non-transitory computer-readable media, including instructions that, when executed by one or more processors of an electronic device, cause the electronic device to perform one or more elements of the method described in or related to any of the foregoing examples or any other method or process described herein.

[0226] Example 23: An apparatus comprising logic, a module, or a circuit for performing one or more elements of a method described in or related to any of the preceding examples or any other method or process described herein.

[0227] Example 24: A method, technique, or process as described or associated with any of the foregoing examples or their parts.

[0228] Example 25: An apparatus comprising one or more processors and one or more computer-readable media including instructions, which, when executed by the one or more processors, cause the one or more processors to perform a method, technique, or process as described or associated with any or a portion of the foregoing examples.

[0229] Example 26: A computer program including instructions, wherein execution of the program by a processing element will cause the processing element to perform a method, technique, or process as described or related to any of the foregoing examples or parts thereof.

[0230] Figure 25This is a block diagram of a machine having an example form of computing system 2500, within which instructions 2524 can be executed to cause computing system 2500 to perform one or more methods discussed herein. In some examples, computing system 2500 includes a machine operating as a stand-alone device, while in other examples, computing system 2500 includes a machine connected (e.g., networked) to other machines. Computing system 2500 may provide or form part of an operating environment for implementing aspects of this disclosure.

[0231] In a networked deployment, a machine can operate as a server or client machine in a server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. The machine can be a computer, tablet, cellular phone, web device, or other machine capable of executing instructions (sequences or others) specifying the actions to be taken by that machine. Note that although in Figure 25 The document illustrates components that are typically associated with only a single machine; however, the term "machine" should also be considered as any collection of machines that individually or jointly execute a set (or more) of instructions to perform any one or more methods discussed herein. Therefore, computing system 2500 may include multiple connected machines. Computing devices can be connected via a network.

[0232] Example computing system 2500 includes one or more processors 2502 (e.g., a central processing unit (CPU), a graphics processing unit (GPU), or both), main or primary memory 2504, and static memory 2506, which communicate with each other via one or more communication connections 2508 (e.g., a bus, controller, or network connection). Computing system 2500 may also include one or more output devices, such as display unit 2510 (e.g., a liquid crystal display (LCD) or a light-emitting diode (LED) display).

[0233] The computing system 2500 also includes one or more input devices, such as input device 2512 (e.g., a keyboard or touch-sensitive display), navigation device 2514 (e.g., a mouse), storage device 2516, signal generation device 2518 (e.g., a speaker), and network interface device 2520. Storage device 2516 includes machine-readable medium 2522 on which one or more sets of data structures and instructions 2524 (e.g., software) are stored, embodying or utilized by one or more methods or functions described herein. Instructions 2524 may also reside wholly or at least partially within main memory 2504 or processor(s) 2502 during execution by the computing system 2500, wherein main memory 2504 and processor(s) 2502 also each constitute machine-readable medium 2522.

[0234] Although machine-readable medium 2522 is shown as a single medium according to some examples, the term "machine-readable medium" can include a single medium or multiple media (e.g., a centralized or distributed database, or associated caches and servers) storing one or more instructions 2524 or data structures. The term "machine-readable medium" should also be considered to include any tangible medium capable of storing, encoding, or carrying instructions 2524 that are executed by a machine and cause the machine to perform any one or more methods of this disclosure, or any tangible medium capable of storing, encoding, or carrying data structures used by or associated with those instructions 2524. Therefore, the term "machine-readable medium" should be considered to include, but is not limited to, solid-state memory as well as optical and magnetic media. Specific examples of machine-readable medium 2522 include non-volatile memory, including, for example, semiconductor memory devices such as erasable programmable read-only memory (EPROM), electrically erasable programmable read-only memory (EEPROM), and flash memory devices; disks, such as internal hard disks and removable disks; magneto-optical disks; and optical disc read-only memory (CD-ROM) and digital universal optical disc read-only memory (DVD-ROM). Machine-readable medium is not a transmission medium.

[0235] Instructions 2524 can also be sent or received on communication network 2526 using a transmission medium. Instructions 2524 can be transmitted using network interface device 2520 and any of many well-known transmission protocols, such as Hypertext Transfer Protocol (HTTP). Examples of communication networks include local area networks (LANs), wide area networks (WANs), the Internet, mobile phone networks, common-use telephone (POTS) networks, and wireless data networks (such as Wi-Fi and Wi-Max networks). The term "transmission medium" should be considered to include any intangible medium capable of storing, encoding, or carrying instructions 2524 that are executed by the machine, and includes digital or analog communication signals or other intangible media that facilitate communication of such software.

[0236] Typically, operating system software (not shown) provides an operating environment for the software executing in computing system 2500 and coordinates the activities of the components of computing system 2500. Based on user input received at computing system 2500, one or more API calls can be made between components of computing system 2500 or between components of computing system 2500 and external components.

[0237] As used herein, the term "processor" can refer to any one or more circuits or virtual circuits (e.g., physical circuits emulated by logic executed on an actual processor) that manipulate data values ​​according to control signals (e.g., commands, opcodes, machine code, control words, macro instructions, etc.) and generate corresponding output signals applied to operate a machine. Processors can include, for example, at least one of a CPU, a Reduced Instruction Set Computing (RISC) processor, a Complex Instruction Set Computing (CISC) processor, a GPU, a Digital Signal Processor (DSP), a Tensor Processing Unit (TPU), a Neural Processing Unit (NPU), a Visual Processing Unit (VPU), a Machine Learning Accelerator, an Artificial Intelligence Accelerator, an Application-Specific Integrated Circuit (ASIC), a Field-Programmable Gate Array (FPGA), a Radio Frequency Integrated Circuit (RFIC), a Neuromorphic Processor, a Quantum Processor, or any combination thereof. A processor can be a multi-core processor having two or more independent processors (sometimes referred to as "cores") capable of executing instructions simultaneously. A multi-core processor can contain multiple computational cores on a single integrated circuit die, each of which can independently execute program instructions in parallel. Parallel processing on multi-core processors can be achieved through architectures such as superscalar, VLIW, vector processing, or SIMD, which allow each core to execute a separate stream of instructions simultaneously. A processor can be emulated as a virtual processor or virtual circuit in software running on a physical processor. A virtual processor can behave like a standalone processor, but is implemented in software rather than hardware.

[0238] The operations of the example methods described herein can be performed, at least in part, by one or more processors that are temporarily configured (e.g., by software) or permanently configured to perform the relevant operations. The execution of certain operations can be distributed across one or more processors, residing not only within a single machine but also deployed across multiple machines. Components of the hardware implementation used to perform the method operations can include dedicated circuitry or logic that is permanently configured (e.g., as a dedicated processor, such as an FPGA or ASIC) to perform certain operations. Components of the hardware implementation can also include programmable logic or circuitry (e.g., contained within a general-purpose processor or another programmable processor) that is temporarily configured by software to perform certain operations.

[0239] One or more processors can operate to support the execution of related operations in a “cloud computing” environment or as “Software as a Service (SaaS)”. For example, at least some operations can be performed by a set of computers (as an example of a machine including processors), and these operations can be accessed via a network (e.g., the Internet) and via one or more appropriate interfaces (e.g., APIs). In practice, some examples can support cloud-based, on-premises-based, or hybrid scenarios.

[0240] Examples can be implemented in digital electronic circuits, or in computer hardware, firmware, or software, or in a combination thereof. Examples can be implemented using computer program products, such as computer programs tangibly embodied in an information carrier (e.g., in a machine-readable medium, for execution by or control of a data processing apparatus, such as a programmable processor, computer, or multiple computers). Computer programs can be written in any suitable programming language, including compiled or interpreted languages, and can be deployed in any form, including as standalone programs or as modules, subroutines, or other units suitable for use in a computing environment. Computer programs can be deployed to execute on a single computer or multiple computers at a single site, or distributed across multiple sites and interconnected via a communication network.

[0241] Although specific examples are described herein, it will be apparent that various modifications and alterations can be made to these examples without departing from the broader spirit and scope of this disclosure. Therefore, the specification and drawings are to be considered illustrative rather than restrictive. The term “example” may be used individually or collectively herein to refer to an example of the subject matter, merely for convenience, and if multiple examples or concepts are indeed disclosed, it is not intended to voluntarily limit the scope of this application to any single example or concept. Therefore, although specific examples have been shown and described herein, it should be understood that this disclosure also covers various adaptations, combinations, or variations of the examples, including structural or logical substitutions and changes.

[0242] Unless otherwise specified, discussions using terms such as “processing,” “computing,” “operation,” “determining,” “presenting,” and “displaying” herein may refer to actions or processes of a machine (e.g., a computer) that manipulate or transform data representing physical (e.g., electronic, magnetic, or optical) quantities within one or more memories (e.g., volatile memory, non-volatile memory, or any suitable combination thereof), registers, or other machine components that receive, store, transmit, or display information. Furthermore, unless otherwise specified, as is common in patent literature, the terms “a” and “an” are used herein to include one or more instances. Where the context permits, the use of singular or plural terms may also include either the plural or the singular, respectively. Unless otherwise specified, the word “or” in relation to a list of two or more items encompasses all of the following interpretations: any one item in the list, all items in the list, and any combination of items in the list.

[0243] As used in this disclosure, phrases such as "at least one of A, B, or C," "at least one of A, B, or C," and "at least one of A, B, and C" should be interpreted as selecting at least one from the group including "A, B, and C." Unless explicitly stated otherwise in connection with specific instances of this disclosure, this phrasing does not imply "at least one of A, at least one of B, and at least one of C." As used in this disclosure, the example "at least one of A, B, or C" will cover any of the following selections: {A}, {B}, {C}, {A,B}, {A,C}, {B,C}, and {A,B,C}.

[0244] While some examples (such as those depicted in the accompanying drawings) include a specific order of operations, this order may be altered without departing from the scope of this disclosure. For example, some of the depicted operations may be performed in parallel or in a different order that does not substantially affect the functionality described in the examples. In other examples, different components of an example device or system implementing the example methods may perform their functions substantially simultaneously or in a specific order. The term "operation" is used to refer to an element in the accompanying drawings of this disclosure for ease of reference, and it should be understood that each "operation" may identify one or more operations, processes, actions, or steps, and may be performed by one or more components.

Claims

1. A system comprising: At least one memory for storing instructions; and One or more processors, when executing instructions, perform operations including the following: Access the knowledge graph data structure stored in the data store; The knowledge graph data structure is preprocessed by replacing instance nodes with class nodes to generate a modified knowledge graph data structure. Automatic detection patterns are achieved by processing modified knowledge graph data structures, including: The path originates from the starting class node in the modified knowledge graph data structure, and The path is recursively expanded until a stopping condition is met, where the attribute-class combination from the current class node in the path has an occurrence frequency exceeding an occurrence threshold; and The knowledge graph data structure stored in the data store is adjusted based on the pattern.

2. The system according to claim 1, wherein, Preprocessing of knowledge graph data structures also includes: By concretizing implicit statements using ontology data structures based on knowledge graph data structures, triple data structures are added to knowledge graph data structures.

3. The system according to claim 1, wherein, Preprocessing of knowledge graph data structures also includes: Add inverse relationships to one or more attributes in a knowledge graph data structure.

4. The system according to claim 1, wherein, An attribute-class combination is a specific attribute-class combination from multiple attribute-class combinations from the current class node. The operation includes: Determine the frequency of occurrence of each of the multiple attribute-class combinations; Determine if the frequency of a specific attribute-class combination exceeds an occurrence threshold; and In response to determining that the frequency of a specific attribute-class combination exceeds an occurrence threshold: Extend paths by combining specific attributes and classes; and Set the target class node of a specific attribute-class combination as the current class node.

5. The system according to claim 1, wherein, The stopping conditions include at least one of the following: A circular pattern was detected in the path; Reaching the maximum number of iterations; or No attribute-class combination was detected that occurs more frequently than the occurrence threshold from the current class node.

6. The system of claim 1, further comprising, before adjusting the knowledge graph data structure stored in the data storage: A confidence score for a pattern is generated by determining the probability of relationships within the pattern and combining the determined probabilities; and Confidence score-based validation model.

7. The system according to claim 1, wherein, Adjustments to the knowledge graph data structure include: The detection detects that the confidence score generated for the pattern exceeds the confidence threshold; and In response to the detection that the confidence score exceeds the confidence threshold, the pattern is automatically merged into the ontology data structure of the knowledge graph data structure.

8. The system of claim 1, further comprising, before adjusting the knowledge graph data structure stored in the data storage: Confidence score of the generated pattern; This enables the presentation of information identifying multiple detected patterns in the user interface on the user device. These multiple detected patterns include patterns and one or more further patterns detected from a modified knowledge graph data structure. The detected patterns are ranked based on their respective confidence scores; as well as Receive user input for validation mode.

9. The system according to claim 1, wherein, Adjusting the knowledge graph data structure includes at least one of the following: Integrate the schema into the ontology data structure of the knowledge graph data structure; or Assertional data structures based on schema-updated knowledge graph data structures.

10. The system according to claim 9, wherein, Adjusting the knowledge graph data structure includes updating the assertion data structure, and updating the assertion data structure includes: Detect at least one incomplete pattern in the knowledge graph data structure that matches a pattern detected using the modified knowledge graph data structure. Generate one or more triplet data structures to complete the at least one incomplete pattern; and Add the one or more triplet data structures to the assertion data structure.

11. The system of claim 10, further comprising: This enables the display of information identifying the one or more triplet data structures in the user interface on the user device; as well as Receive user input for selecting one or more triplet data structures, wherein, in response to receiving user input, the one or more triplet data structures are added to the assertion data structure.

12. The system according to claim 1, wherein, The modes include: Linear patterns, which are applied after pattern detection to expand the ontology data structure of the knowledge graph data structure; or A circular pattern, which is applied after a pattern is detected to expand the assertion data structure of the knowledge graph data structure.

13. The system according to claim 1, wherein the operation further comprises: This enables the display of information identifying multiple classes associated with class nodes in the user interface on the user device; Receive user input to select the class of interest from the plurality of classes; as well as In response to receiving user input that selects a class of interest, configure the processing of the modified knowledge graph data structure so that the class of interest is the starting class node.

14. The system according to claim 1, wherein, The occurrence threshold is selected based on the inheritance depth of one or more class nodes in the class node.

15. A computer-implemented method executed by a computer system, the computer system including a memory and at least one hardware processor, the computer-implemented method comprising: Access the knowledge graph data structure stored in the data store; The knowledge graph data structure is preprocessed by replacing instance nodes with class nodes to generate a modified knowledge graph data structure. Automatic detection patterns are achieved by processing modified knowledge graph data structures, including: The path originates from the starting class node in the modified knowledge graph data structure, and The path is recursively expanded until a stopping condition is met, where the attribute-class combination from the current class node in the path has an occurrence frequency exceeding an occurrence threshold; and The knowledge graph data structure stored in the data store is adjusted based on the pattern.

16. The computer-implemented method according to claim 15, wherein, Preprocessing of knowledge graph data structures also includes: By concretizing implicit statements using ontology data structures based on knowledge graph data structures, triple data structures are added to knowledge graph data structures.

17. The computer-implemented method according to claim 15, wherein, Preprocessing of knowledge graph data structures also includes: Add inverse relationships to one or more attributes in a knowledge graph data structure.

18. One or more non-transitory computer-readable media storing computer-executable instructions, which, when executed by a computing system, cause the computing system to perform operations, including: Access the knowledge graph data structure stored in the data store; The knowledge graph data structure is preprocessed by replacing instance nodes with class nodes to generate a modified knowledge graph data structure. Automatic detection patterns are achieved by processing modified knowledge graph data structures, including: The path originates from the starting class node in the modified knowledge graph data structure, and The path is recursively expanded until a stopping condition is met, where the attribute-class combination from the current class node in the path has an occurrence frequency exceeding an occurrence threshold; and The knowledge graph data structure stored in the data store is adjusted based on the pattern.

19. The one or more non-transitory computer-readable media according to claim 18, wherein, Preprocessing of knowledge graph data structures also includes: By concretizing implicit statements using ontology data structures based on knowledge graph data structures, triple data structures are added to knowledge graph data structures.

20. One or more non-transitory computer-readable media according to claim 18, wherein, Preprocessing of knowledge graph data structures also includes: Add inverse relationships to one or more attributes in a knowledge graph data structure.

Images