Knowledge-based information modeling service platform for autonomous systems

Abstract

A system and method for knowledge-based information modeling using a semantic binding engine that generates a binding configuration based on a legacy domain semantic model extracted from a controller of an autonomous system and a knowledge graph extracted from a knowledge base of domain knowledge related to the autonomous system. The binding configuration represents mappings of standardized model instance components to legacy domain semantic model components. An adapter with a server handles communications related to the standardized information model, including information requests for a set of process variables of the legacy domain semantic model converted using the binding configuration.

Description

Technical Field

[0001] This application relates to autonomous systems. More specifically, this application relates to an information modeling service platform for autonomous systems. Background Technology

[0002] Recent progress has been made in standardizing machine-to-machine cross-platform communication protocols for data acquisition and control of autonomous industrial equipment and systems. One such protocol is the Open Platform Communication (OPC) Unified Architecture (UA). This standardized information model enables interoperability between various industry standards. Machine manufacturers are working to migrate current products to this standardized information model and develop future products that conform to it.

[0003] However, in the case of OPC UA, there is often a lack of consistency between existing engineering assets and OPC UA and its supporting specifications. Therefore, it is common to generate OPC UA information models without structural or contextual information, where variables are simply mirror images of entries in variable tables from legacy automation engineering projects. For example, an OPC UA server can directly derive a "shell" of such a model using only the variable names of existing automation projects, without further effort to make the project conform to domain-specific (e.g., OPC UA) supporting specifications. These projects are ill-suited for future digitization or interoperability. Engineers working on higher-level systems (e.g., the business management layer called Enterprise Resource Planning (ERP) and the plant management layer called Manufacturing Execution Planning (MES)) may need to expend extra effort to recover and understand the meaning of variables, resulting in lost production time. Often, the original context of variables is lost, and therefore must be inferred by engineers through reading numerous documents, guessing, trial and error, or consulting automation systems engineers who may not have access to the information. This inefficient process has become a bottleneck in the conversion of existing systems to full digitization and is also prone to errors and incorrect decisions.

[0004] One root cause of the problem is the lack of appropriate information modeling capabilities in existing engineering tools. For example, Figure 1An example of an engineering tool user interface platform 101 (e.g., the Siemens Totally Integrated Automation (TIA) portal) is shown, which includes a variable table 103 that allows design engineers to set process variables associated with legacy automation system controllers, such as programmable logic controllers (PLCs). In this example, the engineer may be designing or modifying the control processes of a legacy automation system via an OPC UA server, which is introduced into the system as a recent addition to accommodate newer components. As shown, variables can be exported to folder 102 on the OPC UA server. However, the engineering tool lacks the ability to attach any additional structural / contextual information, and therefore the OPC UA server lacks interoperability potential with standards-compliant OPC UA models.

[0005] Tools have been developed to partially alleviate the missing links in the transition from the existing automation-oriented control paradigm to a new digital paradigm, such as OPC UA. Figure 2 The OPC UA modeling editor 231 is shown, which includes visualization tools for modifying existing information models 225 with an unknown system architecture 223 for an OPC UA server 221 according to the supporting specification 233 and integrating these models with TIA projects. Editor 231 allows engineers to manually label components of the OPC UA information model, but this labeling is based on the engineer's decisions, and therefore any added metadata is not guaranteed to be consistent with standards. For example, a user may choose to copy only a small portion of the supporting specification to the information model in the OPC UA server, or add, delete, or change some variables without referring to the supporting specification. There are no guidelines or restrictions on the parts to be copied or the types / names of variables to be used.

[0006] Figure 3 An example of a modeling tool is shown for automatically converting an existing information model into an OPC UA server source code framework. The model designer 321 can interact with the information model 311, featuring a GUI editor and simple functionality for displaying (e.g., adding / modifying objects, types, or references in the UA model) to arbitrarily modify the existing model. The code generator 331 then produces source files 341. Figure 2 and Figure 3 Both solutions illustrated rely on the tool user's understanding of domain-related standards and specifications to construct an appropriate information model. However, these tools do not mandate that the published information model conform to relevant standards or specifications, nor do they allow users to bind information related to the automation system to nodes in the OPC UA server model representation. Summary of the Invention

[0007] Various aspects of embodiments of this disclosure include processes and systems for knowledge-based information modeling of automated systems using a service platform. The service platform may include multiple modules, including a semantic building engine and an adapter. The semantic binding engine can generate binding configurations based on a semantic model extracted from a legacy model and a knowledge graph. The adapter may include a server and a converter. The server can handle communications related to the information model, including information requests received from external interfaces and information responses sent on external interfaces. The communications can be formatted according to standardized industry protocols, and the information requests relate to data associated with a controller of the legacy system. The converter can reference one or more process variables to convert information requests into legacy-based information requests and can send requests to the controller to obtain legacy-based information requests, wherein the conversion is based on the binding configuration.

[0008] In one embodiment, the service platform is provided with a built-in machine semantic model and skill model. In another embodiment, the service platform can be provided to generate an information model that requires only a limited number of conditions, which may include machine skills (e.g., pressurization) and machine type (e.g., hydraulic press), target protocol (e.g., OPC UA), access to existing machines, and specifying relevant parameters and attributes (e.g., maximum accuracy) based on the skill model. Attached Figure Description

[0009] The following figures illustrate a non-limiting and non-exhaustive embodiment of this invention, wherein, unless otherwise specified, the same reference numerals refer to the same elements throughout the figures.

[0010] Figure 1 This shows an example of a variable table presented by the engineering tool user interface platform.

[0011] Figure 2 and Figure 3 Examples of engineering tools for transforming information models into new digital paradigms are shown.

[0012] Figure 4 A system flowchart illustrating an example of a service platform for building an autonomous system based on a knowledge-based information model according to one or more embodiments of the present disclosure is provided.

[0013] Figure 5 Examples of binding configurations according to one or more embodiments of this disclosure are shown.

[0014] Figure 6 A system flowchart illustrating an example of runtime access to information model data according to one or more embodiments of this disclosure is provided.

[0015] Figure 7 An example of a runtime integration system according to one or more embodiments of the present disclosure is shown.

[0016] Figure 8 An exemplary computing environment in which embodiments of this disclosure may be implemented is shown. Detailed Implementation

[0017] Methods and systems are disclosed for performing information modeling of legacy systems using a service platform, transforming and enriching flat models into more contextualized models, such as models conforming to standardized digitization protocols (e.g., OPC UA). The service platform includes a semantic binding engine that generates candidate configurations for new information models and selects the binding configuration that maps the legacy model to the new model. Semantic binding configurations are formed by comparing existing models extracted from the legacy system with available domain knowledge. A knowledge base stores accumulated domain knowledge with a specific degree of determinism using machine learning processes. In semantic binding, components of the legacy system are mapped to candidate nodes of model instances of the new information model, which can be ranked by likelihood as binding suggestions, derived using domain knowledge. Binding configuration decisions can be made from binding suggestions based on project documents, surveys, or other evidence. The disclosed methods and systems aim to build enhanced information models with higher reliability and compliance with relevant standards. Traditional methods fail to apply historical domain knowledge across the entire system to information models, relying solely on the knowledge of developers, which can lead to unreliable modeling. Using the publicly available service platform, and leveraging the advantages of knowledge-based machine learning, a candidate ranking set of information model instances is presented.

[0018] Figure 4 A system flowchart illustrating an example of a service platform for building a knowledge-based information model of an autonomous system according to one or more embodiments of the present disclosure is provided. System 400 includes a service platform 415, an adapter 422, and a resource manager component 413 for modeling an autonomous system 432. In embodiments, the service platform 415 may be integrated to include the adapter 422 and the resource manager 413. Prior to the engineering phase, a domain knowledge graph can be created by transforming existing domain knowledge 412 into a specification, standard, or proprietary form. Some knowledge may already have well-defined information models (e.g., in Extensible Markup Language (XML)) that can be easily converted into ontology, but other knowledge may need to be jointly managed by knowledge engineers and domain experts. Knowledge may also come from Natural Language Processing (NLP) input to map unstructured manuals or documents to a structured knowledge graph. As an example of using NLP to build a knowledge graph (e.g., a knowledge graph template) for a milling machine, proprietary information may include statements such as “all milling machines require at least one rotational speed input (e.g., variable name 'speed') and an output indicating whether the milling process was successfully completed (e.g., variable name 'success')”. Knowledge graphs can be stored in Knowledge Base 416 based on any readily available graph database format (e.g., Resource Description Framework (RDF)).

[0019] During the engineering phase, the resource manager component 413 can connect to the legacy autonomous system 432 to leverage existing information models (e.g., legacy domain information models using any industrial automation protocol) and data available in the storage information model. For example, the resource manager 413 can access an OPC UA server or a programmable logic controller (PLC). While standardized information model templates (e.g., OPC UA) offer a rich selection of possible layers and component types, the initial actual models built often have the lowest level of information to define model instances (i.e., “flat” models lacking context) due to a lack of knowledge, time, or the engineer’s skill level. For example, a legacy domain information model may include labeled or numbered variables, but lacks any context to help engineers understand their association with specific system components or properties, thus preventing the generation of an OPC UA model with its full contextual potential. One problem that needs to be addressed is to develop and contextualize enhanced, standards-compliant information models that enable new projects to design integrations with improved system-wide identification of process variables, data types, and methods. Examples of the required transformation may be in response to information being processed in different ways, such as hierarchical connections for conforming to a standard model, while the legacy domain information model is organized in a different way (e.g., variable names arranged alphabetically). In one embodiment, the legacy domain information model is refactored to produce an enhanced information model that is manufacturer-agnostic for the autonomous controller 433, as well as resident engineering documentation inherent to the specific controller and previous engineers. The enhanced information model is extracted from all available knowledge base resources to enable broader contextualization and reliably converted into a standardized representation for use in more general functions.

[0020] In one embodiment, resource manager 413 can extract process variables from autonomous controller 433, generate a list of all extracted process variable data, and identify any existing structure of the process variable data, such as components and relationships. For example, graphical visualization tools can be used to generate a graphical representation of a semantic model to represent sensor components and motion control components bound to a specific machine in autonomous system 432, which have interoperability relationships with sensor components and motion control components associated with the surrounding machine and operating environment. In one embodiment, resource manager component 413 can identify existing information models (e.g., a planar OPC UA model) and can convert the acquired information model into a semantic model as input to semantic binding engine 417. For example, resource manager 413 reads a legacy model and converts that information into a knowledge graph representation as a semantic model in a format ready for processing by service platform 415 (e.g., an intermediate format). Resource manager component 413 can be configured as a Representational State Transfer (REST) ​​server and can use any off-the-shelf REST framework.

[0021] Semantic binding engine 417 can compare the semantic model from resource manager 413 with one or more knowledge graphs 451 from knowledge base 416 based on graph similarity to determine which components and / or nodes of the normalized model (e.g., OPC UA) may be consistent with component tuning of autonomous system 432. In one embodiment, semantic binding engine 417 can apply text matching (e.g., name, description, or other text information) using one or more matching algorithms, such as fuzzy string matching or word embedding (i.e., statistical learning from existing documents). Semantic binding engine 417 can apply structural matching algorithms to hierarchical information (e.g., hasComponent, sibling nodes, child nodes, etc.), which can apply negative exponential distance between nodes. In one embodiment, semantic binding engine 417 can analyze components in the semantic model to achieve accurate contextualization (e.g., determining whether a temperature value information element identified by "Fahrenheit" is related to a room temperature sensor or a physical device temperature sensor). In an example where the semantic model includes OPC UA modeling, matching can be based on one or more metadata and / or model nodes (e.g., data type, node class, engineering unit, etc.) using fuzzy data type matching. For example, the process variable of room temperature measurement may be part of the precision milling machine information model to ensure that the milling process on the work item is not adversely affected by the ambient temperature. The semantic binding engine 417 can determine the relationship based on information from the knowledge base 416, and the semantic binding engine 417 can ensure that the semantic model includes the contextual relationship and variable context.

[0022] The comparison by the semantic binding engine 417 can be determined as a mapping function that generates semantic bindings between the contextual information base of the standardized information model and the components in the autonomous system 432. As an option to enhance the mapping (e.g., in cases where some variables in the accompanying specification are not properly bound and user assistance is needed to verify the semantic bindings of the variables), candidate nodes of the standardized model instances can be sorted by likelihood according to the algorithm of the semantic binding engine 417, which can be presented to the project engineer 414 as binding suggestions via the user interface 418 (e.g., displayed on a monitor). The sorting can be performed using a string matching algorithm to measure the similarity of subgraphs. For example, the instance “temperature reading” may be a better match for the variable “humidity” than for the variable “temperature”. Alternatively, the data type of the matching algorithm can be applied (e.g., matching legacy domain “Int” data that is compatible with standard-compliant “Float32” data).

[0023] User interface 418 can receive input from project engineer 414 related to confirmation or revision of binding recommendations, which may be based on project documents, surveys, experience, or other available domain-specific technologies. Binding results, such as a user's selection of a sorting candidate or a modified version of the binding recommendation, can be generated from user input at user interface 418 and then sent to semantic binding engine 417, which generates binding configuration 425.

[0024] Binding configuration 425 can be stored by knowledge base 416 as input to machine learning algorithm 419 to provide more accurate recommendations in the future. Binding configuration 425 can also be stored by adapter 422, which includes pointers to model instance information 423 obtained from knowledge base 416. Adapter 422 can be configured to transform external requests during runtime using server 424 and converter 426 to access specific data points in the information model, as described below.

[0025] Figure 5 Examples of binding configurations for model instances according to one or more embodiments of the present disclosure are shown. In one embodiment, binding configuration 502 may be... Figure 4 The implementation of binding configuration 425 is shown. Binding configuration 502 is a mapping from legacy database address 501 to information model instance 503 (such as components and / or nodes of the OPC UA information model). In this example, legacy database address DB2:6.0 maps to component namespace 2 (Ns=2) at node ID 1005 (i=1005) in the information model. In one embodiment, the model instance 503 used for binding configuration 502 includes a large amount of contextual information, such as metadata. Figure 5 The example shown, model instance 503, includes multiple components, including a UA object 511 named "Temperature Sensor," a UA variable 512 named "Temperature," and a UA variable 513 named "Range," which describes "monitored temperature of the boiler" and provides a defined range of engineering units (EUs) (e.g., temperature range), and a UA object 514 named "Engineering Units," which provides the unit of the value (e.g., degrees Celsius). One advantage of this embodiment is the automatic mapping between the OPC UA and the domain information model, which, without which, would require project engineers to manually input (e.g., keyboard input or establishing links between nodes using some visual modeling tool). An example of a standardized information model visualization is shown as OPC UA model visualization 504, which may include hierarchical data structures, or other "user-friendly" visualizations of model instance components 511, 512, 513, and 514 as shown. Such visualizations can be useful during the engineering phase, as binding configurations are being generated for feedback and progress tracking purposes.

[0026] Figure 6 A system flowchart illustrating an example of runtime access to information model data according to one or more embodiments of the present disclosure is provided. Adapter 422 may include a server 613 (e.g., an OPC UA server) for processing access requests for model information and a converter 615 for translating communication between model standards (e.g., OPC UA) and model convention terminology of legacy controllers, whereby adapter 422 acts as a gateway for accessing legacy system controllers for modeling, and all data and control messages pass through adapter 422. To initialize adapter 422 for runtime operation, server 613 may read all stored model instances 423, which may be stored in local memory or in a knowledge base 416 (see [link to relevant documentation]). Figure 4 Model instance 423 can be presented to server 613 as an information model, allowing users to access model information in a useful way. For example, data from server 613 can help users determine whether additional useful metadata for a particular variable is available for a node instance of the information model.

[0027] Once initialized, adapter 422 is ready to process information requests. Server 613 can receive external access requests for specific data points via external interface 601. For example, an external access request could take the form of "requesting temperature readings for boiler 11". Converter 615 can translate the request from one protocol (e.g., OPC UA) to another protocol (e.g., Legacy Autonomous Systems Model Language) based on binding configuration 425 that maintains the mapping. The translated information may include address space, data format, cell, data type, engineering cell, and the like. The translated request can be forwarded to controller 433 in legacy system 432 for retrieval (e.g., real-time sensor readings of boiler 11 temperature). For example, converter 615 can receive a request that includes a reference to an OPC UA instance and then use binding configuration 425 to map and extract legacy versions of associated variables during the reverse mapping process. The translated request can be sent by converter 615 to legacy controller 433 using data and control link 631. For example, converter 615 can identify from binding configuration 425 the existence of three legacy variables associated with an OPC UA instance. Using contextualization provided by a knowledge model built into the binding configuration, the information model can include functions as standard outputs, such as functions of average temperature (in Fahrenheit). For example, the inverse mapping can be complex, such as 1:1000 variables (e.g., the average temperature of 1000 sensors placed in an autonomous system).

[0028] Embodiments of this disclosure enable legacy systems to be adapted to conform to industry standards based on standardized information models (e.g., OPC UA), supporting specifications, internal product protocols, and other relevant domain standards and / or specifications. Therefore, products and engineering solutions for associated autonomous systems can be released with higher quality and in less time. The rich metadata added to the disclosed service platform also helps end users automate their system integration, as data can be exchanged between systems according to meaning and context, significantly reducing resource expenditures for case-by-case linked systems.

[0029] In one embodiment, the disclosed system can be implemented as a cloud-based service platform solution residing in a cloud server. For the initial deployment of the service platform, the binding recommendations of the semantic binding engine are primarily based on domain-specific technologies. As more OEM users progressively deploy the service platform over time to adapt their legacy systems, accumulating more and more domain knowledge, the cloud-based service platform can further learn from the various configurations obtained from the feedback of binding configurations. Therefore, one advantage of the disclosed system is that it can start from basic domain-specific technologies and progressively build and complete knowledge using machine learning methods. While purely knowledge-based systems are very expensive and slow to build, and purely machine learning systems require a large amount of upfront data, the service platform embodiments of this disclosure provide a balance between the two approaches.

[0030] Figure 4 The solution presented can enable the service platform to run in the cloud. However, the service platform can also run locally, which may be preferred for users who, for example, are concerned about the confidentiality of their control data. Figure 7 An example of an integrated system according to one or more embodiments of the present disclosure is shown. The integrated system 701 may deploy a built-in or embedded adapter 711 within a controller 713, wherein a binding configuration 714 is directly available to the controller 713. In one embodiment, the adapter 711 may include a... Figure 6 The server 613 (e.g., an OPC UA server) and converter 615 shown are servers and converters. The integrated system 701 is able to serve external requests via external interface 705 with lower overhead and potentially higher performance.

[0031] Figure 8 An exemplary computing environment in which embodiments of this disclosure may be implemented is shown. For example... Figure 8 As shown, the computer system 810 may include a communication mechanism such as a system bus 821 or other communication mechanisms for communicating information within the computer system 810. The computer system 810 also includes one or more processors 820 coupled to the system bus 821 to process information.

[0032] Processor 820 may include one or more central processing units (CPUs), graphics processing units (GPUs), or any other processor known in the art. More generally, a processor as described herein is a device for executing machine-readable instructions stored on a computer-readable medium for performing tasks and may include any one or a combination of hardware and firmware. The processor may also include memory storing machine-readable instructions executable for performing tasks. The processor operates on information by manipulating, analyzing, modifying, transforming, or transmitting information for use by an executable process or information device, and / or by routing information to an output device. The processor may use or include the capabilities of, for example, a computer, controller, or microprocessor, and uses executable instructions to regulate the processor to perform special-purpose functions not performed by a general-purpose computer. The processor may include any type of suitable processing unit, including but not limited to central processing units, microprocessors, reduced instruction set computer (RISC) microprocessors, complex instruction set computer (CISC) microprocessors, microcontrollers, application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), system-on-a-chip (SoCs), digital signal processors (DSPs), and the like. Furthermore, the processors 820 can have any suitable microarchitecture design, including any number of constituent components such as, for example, registers, multiplexers, arithmetic logic units, cache controllers for controlling read / write operations on cache memory, branch predictors, or the like. The processor's microarchitecture design can support any of a variety of instruction sets. The processor can be coupled (electrically coupled and / or as an executable component) to enable interaction and / or communication between them. The user interface processor or generator is a known element, including electronic circuitry or software, or a combination of both, for generating display images or portions thereof. The user interface includes one or more display images, enabling the user to interact with the processor or other devices.

[0033] System bus 821 may include at least one of a system bus, memory bus, address bus, or message bus, and may allow the exchange of information (e.g., data (including computer-executable code), signaling, etc.) between various components of computer system 810. System bus 821 may include, but is not limited to, a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and the like. System bus 821 may be associated with any suitable bus architecture, including but not limited to Industry Standard Architecture (ISA), Micro Channel Architecture (MCA), Enhanced ISA (EISA), Video Electronics Standards Association (VESA) architecture, Accelerated Graphics Port (AGP) architecture, Peripheral Component Interconnect (PCI) architecture, PCI-Express architecture, Personal Computer Memory Card International Association (PCMCIA) architecture, Universal Serial Bus (USB) architecture, and the like.

[0034] Continue to refer to Figure 8 The computer system 810 may also include a system memory 830 coupled to a system bus 821 for storing information and instructions to be executed by the processor 820. The system memory 830 may include computer-readable storage media in the form of volatile and / or non-volatile memory, such as read-only memory (ROM) 831 and / or random access memory (RAM) 832. RAM 832 may include other dynamic storage devices (e.g., dynamic RAM, static RAM, and synchronous DRAM). ROM 831 may include other static storage devices (e.g., programmable ROM, erasable PROM, and electrically erasable PROM). Furthermore, the system memory 830 may be used to store temporary variables or other intermediate information during the execution of instructions by the processor 820. A basic input / output system 833 (BIOS) containing basic routines such as those that facilitate the transfer of information between components within the computer system 810 during startup may be stored in the ROM 831. RAM 832 may contain data and / or program modules 838 that are immediately accessible to and / or currently operating on by the processor 820. The system memory 830 may also include, for example, an operating system 834, application programs 835, and other program modules 836.

[0035] Operating system 834 may be loaded into memory 830 and may provide an interface between other application software executing on computer system 810 and the hardware resources of computer system 810. More specifically, operating system 834 may include a set of computer-executable instructions for managing the hardware resources of computer system 810 and providing common services to other applications (e.g., managing memory allocation among various applications). In some example embodiments, operating system 834 may control the execution of one or more program modules described as being stored in data storage 840. Operating system 834 may include any operating system now known or that may be developed in the future, including but not limited to any server operating system, any mainframe operating system, or any other proprietary or non-proprietary operating system.

[0036] According to embodiments of this disclosure, application program 835 may be a set of computer-executable instructions for performing the above-described process.

[0037] Computer system 810 may also include a disk / media controller 843 coupled to system bus 821 to control one or more storage devices, such as hard disk 841 and / or removable media drive 842 (e.g., floppy disk drive, optical disk drive, tape drive, flash memory drive, and / or solid-state drive), for storing information and instructions. Storage device 840 may be added to computer system 810 using a suitable device interface (e.g., Small Computer System Interface (SCSI), Integrated Device Electronics (IDE), Universal Serial Bus (USB), or FireWire). Storage devices 841, 842 may be located external to computer system 810 and may be used for storing processed data according to embodiments of this disclosure.

[0038] Computer system 810 may also include a display controller 865 coupled to system bus 821 to control a display or monitor 866, such as a cathode ray tube (CRT) or liquid crystal display (LCD), for displaying information to a computer user. The computer system includes a user input interface 860 and one or more input devices, such as a user terminal 861, which may include a keyboard, touchscreen, tablet, and / or pointing device, for interacting with the computer user and providing information to processor 820. Display 866 may provide a touchscreen interface, allowing input to supplement or replace communication and command selection for orientation information of user terminal device 861.

[0039] Computer system 810 may perform some or all of the processing steps of embodiments of the present invention in response to processor 820 executing one or more sequences of one or more instructions contained in memory (such as system memory 830). These instructions may be read into system memory 830 from another computer-readable medium (such as hard disk 841 or removable media drive 842). Hard disk 841 may contain one or more data stores and data files used by embodiments of the present invention. Data stores may include, but are not limited to, databases (e.g., relational, object-oriented, etc.), file systems, flat files, distributed data stores where data is stored across multiple nodes of a computer network, peer-to-peer network data stores, or the like. Processor 820 may also be used in a multiprocessing arrangement to execute one or more sequences of instructions contained in system memory 830. In alternative embodiments, hardwired circuitry may be used in place of or in combination with software instructions. Therefore, embodiments are not limited to any particular combination of hardware circuitry and software.

[0040] As described above, computer system 810 may include at least one computer-readable medium or memory for storing instructions programmed according to embodiments of the present invention and for containing data structures, tables, records, or other data as described herein. The term "computer-readable medium" as used herein refers to any medium that participates in providing instructions to processor 820 for execution. Computer-readable media can take many forms, including but not limited to non-transitory, non-volatile, volatile, and transmission media. Non-limiting examples of non-volatile media include optical disks, solid-state drives, magnetic disks, and magneto-optical disks, such as hard disk 841 or removable media drive 842. Non-limiting examples of volatile media include dynamic memory, such as system memory 830. Non-limiting examples of transmission media include coaxial cables, copper wires, and optical fibers, including conductors constituting system bus 821. Transmission media may also take the form of acoustic or optical waves, such as acoustic or optical waves generated during radio wave and infrared data communication.

[0041] Computer-readable medium instructions used to perform the operations of this disclosure may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, status setting data, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Simultalk, C++, or similar, and conventional programming languages ​​such as the "C" programming language or similar. The computer-readable program instructions may be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter case, the remote computer may be connected to the user's computer via any type of network including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet provided by an Internet service provider). In some embodiments, electronic circuitry including, for example, programmable logic circuitry, field-programmable gate arrays (FPGAs), or programmable logic arrays (PLAs) may be personalized to perform various aspects of this disclosure by executing the computer-readable program instructions using status information provided by the computer-readable program instructions.

[0042] This document describes various aspects of the disclosure with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the disclosure. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of each block of the flowchart illustrations and / or block diagrams, can be implemented using computer-readable medium instructions.

[0043] The computing environment 800 may also include a computer system 810 operating in a network environment using logical connections to one or more remote computers (such as remote computing devices 880). A network interface 870 enables communication with other remote devices 880 or system and / or storage devices 841, 842, for example, via a network 871. The remote computing device 880 may be a personal computer (laptop or desktop), mobile device, server, router, network PC, peer-to-peer device, or other public network node, and typically includes many or all of the elements described above relative to the computer system 810. When used in a network environment, the computer system 810 may include a modem 872 for establishing communication via a network 871 (such as the Internet). The modem 872 may be connected to the system bus 821 via a user network interface 870 or via another suitable mechanism.

[0044] Network 871 can be any network or system known in the art, including the Internet, intranet, local area network (LAN), wide area network (WAN), metropolitan area network (MAN), direct connection or a series of connections, cellular telephone network, or any other network or medium capable of facilitating communication between computer system 810 and other computers (e.g., remote computing device 880). Network 871 can be wired, wireless, or a combination thereof. Wired connections can be implemented using Ethernet, Universal Serial Bus (USB), RJ-6, or any other wired connection commonly known in the art. Wireless connections can be implemented using Wi-Fi, WiMAX and Bluetooth, infrared, cellular networks, satellite, or any other wireless connection method known in the art. Furthermore, multiple networks can operate independently or communicate with each other to facilitate communication within network 871.

[0045] It should be understood that, such as Figure 8 The program modules, applications, computer-executable instructions, code, or similar objects described and stored in system memory 830 are illustrative and not exhaustive, and the processing described as being supported by any particular module may alternatively be distributed across multiple modules or executed by different modules. Furthermore, various program modules(s), scripts(s), plugins(s), application programming interfaces(s), or any other suitable computer-executable code (hosted on the local computer system 810, remote device 880, and / or hosted on other computing devices(s) accessible via one or more networks 871) may be provided to support processing by... Figure 8 The functions and / or additional or alternative functions provided by the program modules, applications, or computer-executable code described herein. Furthermore, functions can be modularized differently, such that they are described as being provided by… Figure 8The processing collectively supported by the set of program modules described herein can be performed by fewer or more modules, or can be at least partially supported by another module, as described herein, which supports functionality by any particular module. Furthermore, the program modules supporting the functionality described herein can form part of one or more applications executable across any number of systems or devices, based on any suitable computing model (e.g., client-server model, peer-to-peer model, and the like). Additionally, the functionality described herein... Figure 8 Any functionality supported by any program module described herein can be implemented, at least in part, across any number of devices in hardware and / or firmware.

[0046] As used herein, an executable application includes code or machine-readable instructions for adjusting a processor to perform a predetermined function, such as an operating system, context data acquisition system, or other information processing system in response to user commands or input. An executable process is a segment of code or machine-readable instructions, subroutines, or other distinct code segments or part of an executable application for performing one or more specific procedures. These processes may include receiving input data and / or parameters, performing operations on received input data and / or performing functions in response to received input parameters, and providing output data and / or parameters.

[0047] The functions and processing steps described herein can be executed automatically, in whole or in part, based on user commands. Activities (including steps) are executed automatically in response to one or more executable instructions or device operations without the user directly initiating the activity.

[0048] The systems and processes shown in the figures are not unique. Other systems, processes, and menus can be derived from the principles of the invention to achieve the same objectives. Although the invention has been described with reference to specific embodiments, it should be understood that the embodiments and variations shown and described herein are for illustrative purposes only. Modifications to the present design can be made by those skilled in the art without departing from the scope of the invention. As described herein, various systems, subsystems, agents, managers, and processes can be implemented using hardware components, software components, and / or combinations thereof. No element of any claim herein shall be construed in accordance with 35 U.S.SC112(f) unless the element is explicitly stated using the phrase “means for…”.

Claims

1. A system for knowledge-based information modeling, comprising: At least one storage device stores a knowledge base and computer-executable instructions configured as one or more modules; as well as At least one processor is configured to access the at least one storage device and execute the instructions, wherein the module includes: A semantic binding engine is configured to generate binding configurations based on a legacy domain semantic model extracted from the controller of the autonomous system and a knowledge graph extracted from a knowledge base of domain knowledge associated with the autonomous system. The binding configurations represent mappings from standardized model instance components to components of the legacy domain semantic model. The semantic binding engine is further configured to compare the semantic model with one or more knowledge graphs based on graph similarity to determine which components and / or nodes of the standardized model may be consistent with components of the autonomous system, thereby generating the binding configurations. The adapter includes: A server is configured to handle communications related to a standardized information model, wherein the communications include information requests received from an external interface and information responses sent on the external interface; wherein the information requests relate to data associated with the controller; and A converter is configured to convert each of the information requests into a set of process variables of the legacy domain semantic model and send a request to the controller to obtain information of the information request, wherein the conversion is based on the binding configuration.

2. The system according to claim 1, wherein, The semantic binding engine and adapter module are deployed as a cloud-based system, which accesses multiple binding configurations associated with multiple corresponding autonomous systems; wherein the multiple binding configurations are stored in the knowledge base, and the module further includes: A machine learning module is used to process a series of binding configurations to optimize the knowledge base and generate a likelihood ranking of binding suggestions; The semantic binding engine updates the information model based on an optimized knowledge base and a new ordering of the binding suggestions.

3. The system according to claim 1, wherein, The binding engine is also configured to: Based on the binding engine's algorithm, binding suggestions for candidate nodes are generated for model instances of the normalized model sorted by likelihood. The binding configuration is based on the user selection of candidate nodes.

4. The system according to claim 3, wherein, The binding engine is also configured to: Generate multiple binding configurations, each for a corresponding model instance; The knowledge base is also configured to store the multiple binding configurations.

5. The system according to claim 1, wherein, During the initialization of the adapter for runtime operation, the server reads multiple standardized model instances of the corresponding binding configuration and displays the standardized model to assist the information request.

6. The system according to claim 1, further comprising: The resource manager component is configured to extract process variable data from the controller, identify the existing structure of the process variables, and convert the legacy domain information model into the legacy domain semantic model.

7. The system according to claim 1, wherein, The adapter is embedded in the controller.

8. A method for knowledge-based information modeling, comprising: The service platform generates a binding configuration based on a legacy domain semantic model extracted from the controller of the autonomous system and a knowledge graph extracted from a knowledge base of domain knowledge associated with the autonomous system. The binding configuration represents a mapping from standardized model instance components to components of the legacy domain semantic model. The semantic model is compared with one or more knowledge graphs based on graph similarity to determine which components and / or nodes of the standardized model may be consistent with components of the autonomous system, thereby generating the binding configuration. The service platform handles communications related to the standardized information model, wherein the communications include information requests received from an external interface and information responses sent on the external interface; wherein the information requests relate to data associated with the controller; and The service platform converts each information request into a set of process variables of the legacy domain semantic model and sends a request to the controller to obtain the information request information, wherein the conversion is based on the binding configuration.

9. The method according to claim 8, wherein, The semantic binding engine and adapter module are deployed as a cloud-based system that accesses multiple binding configurations associated with multiple corresponding autonomous systems; wherein the multiple binding configurations are stored in the knowledge base, and the module further includes: A machine learning module is used to process a series of binding configurations to optimize the knowledge base and generate a likelihood ranking of binding suggestions; The semantic binding engine updates the information model based on an optimized knowledge base and a new ranking of binding suggestions.

10. The method of claim 8, further comprising: Based on the binding engine's algorithm, binding suggestions for candidate nodes are generated for model instances of the normalized model sorted by likelihood. The binding configuration is based on the user selection of candidate nodes.

11. The method of claim 10, further comprising: Generate multiple binding configurations, each for a corresponding model instance; The knowledge base is also configured to store the multiple binding configurations.

12. The method according to claim 8, further comprising: During the initialization of the service platform for runtime operations, multiple standardized model instances with corresponding binding configurations are read and the standardized models are displayed to assist the information request.

13. The method of claim 8, further comprising: Process variable data is extracted from the controller, the existing structure of the process variables is identified, and the legacy domain information model is converted into the legacy domain semantic model.

Images