Robotic Capability Model for Artificial Intelligence Assisted Manufacturing Supply Chain Planning
20170278000 · 2017-09-28
Inventors
Cpc classification
Y02P90/02
GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
International classification
Abstract
A computer-implemented method for automating manufacturing supply chain planning, comprising: (a) providing a computer processor for processing data; (b) providing at least one input device; (c) providing at least one output device; (d) providing a computer readable storage device; (e) providing a first ontology for defining a product in terms of the method of manufacture of said product or for defining a plurality of products in terms of the method of manufacture of said products; (f) providing a second ontology for defining the capabilities of a plurality of manufacturing facilities; and g) providing a knowledge representation and reasoning system executed on said computer processor.
Claims
1. A computer-implemented method for automating manufacturing supply chain planning, comprising: a) providing a computer processor for processing data; b) providing at least one input device; c) providing at least one output device; d) providing a computer readable storage device; e) providing a first ontology for defining a product in terms of the method of manufacture of said product or for defining a plurality of products in terms of the method of manufacture of said products; f) providing a second ontology for defining the capabilities of a plurality of manufacturing facilities; g) providing a knowledge representation and reasoning system executed on said computer processor which will: i) access said computer readable storage device for reading said first ontology and said second ontology, ii) receive a request describing the method of manufacture of a product in terms of said first ontology, iii) deduce through a system of logic using request in (ii) and using said second ontology a manufacturing plan detailing how to produce the product described in (ii) using a list of manufacturing facilities; and wherein said knowledge representation and reasoning system will output an analysis of the feasibility of the manufacture of said product, and/or wherein the manufacture of said product is feasible will output a plan detailing how to manufacture said product and/or wherein the manufacture of said product is feasible will output a plan detailing how to manufacture said product using a list of said manufacturing facilities.
2. The computer-implemented method of claim 1, wherein said manufacturing facilities are robotic.
3. The computer-implemented method of claim 1, wherein said second ontology will categorize capabilities of manufacturing facilities using hierarchical classification.
4. The computer-implemented method of claim 1, wherein said knowledge representation and reasoning system will further receive changes to said first ontology and storing said first ontology on said storage medium whereby a human operator can effect editing and modification of said first ontology.
5. The computer-implemented method of claim 1, wherein said knowledge representation and reasoning system will further receive changes to said second ontology and storing said second ontology on said storage medium whereby a human operator can effect editing and modification of said first ontology.
6. The computer-implemented method of claim 1, wherein said knowledge representation and reasoning system will further furnish explanations for its reasoning about said manufacturing plan whereby a human operator can be made to understand said knowledge representation and reasoning system's logic and is therefore able to improve product designs.
7. The computer-implemented method of claim 1, wherein said knowledge representation and reasoning system will further use a neural network in its reasoning about said manufacturing plan whereby logic based reasoning is complemented with reasoning based on machine learning.
8. The computer-implemented method of claim 1, wherein said knowledge representation and reasoning system will further use regression analysis to optimize said manufacturing plan whereby logic based reasoning is complemented with statistical reasoning.
9. The computer-implemented method of claim 1, wherein said knowledge representation and reasoning system will further apply quantitative constraints imposed upon product specifications in its reasoning about said manufacturing plan.
10. The computer-implemented method of claim 1, wherein said knowledge representation and reasoning system will further apply qualitative constraints imposed upon product specifications in its reasoning about said manufacturing plan.
11. The computer-implemented method of claim 1, wherein said knowledge representation and reasoning system will further use the artificial intelligence Knowledge Interchange Format to represent said first ontology and said second ontology.
12. The computer-implemented method of claim 1, further providing a computer-implemented method for visually modeling product designs comprising: a) providing a display; b) receiving input from a human operator using interconnected; graphical symbols representing computer programming language elements to describe products in terms of said first ontology which will: i) validate interconnections of graphical symbols according to geometric properties of graphical symbols in the context of said first ontology whereby the syntactic correctness of interconnected graphical symbols is verified, and ii) validate inputs of graphical symbols representing computer programming language using said knowledge representation and reasoning system in the context of said first ontology whereby the semantics of input of graphical symbols representing computer programming language is verified against said first ontology; c) displaying designs of products in terms of said first ontology using interconnected graphical symbols on said display; d) rendering graphically designs of product in terms of said first ontology on said display whereby a human operator can visualize products being designed, wherein a human operator enjoys the benefit of an artificial intelligence assisted graphical product development environment to aid assisting in product design.
13. The computer-implemented method of claim 12, wherein receiving input from a human operator using interconnected graphical symbols representing computer programming language elements to describe products in terms of said first ontology will further validate inputs of graphical symbols representing computer programming language using incremental compilation techniques whereby the syntactic correctness of interconnected graphical symbols is ensured.
14. The computer-implemented method of claim 12, wherein receiving input from a human operator using interconnected graphical symbols representing computer programming language elements to describe products in terms of said first ontology will further validate parameterized inputs to graphical symbols that represent computer programming language constructs according to geometric properties of these graphical symbols and the geometric properties of their inputs whereby the syntactic correctness of interconnected graphical symbols and their inputs is verified and whereby higher order logic computer language constructs are enabled.
15. The computer-implemented method of claim 1, wherein said first ontology is implemented as a formal naming and/or definition of types and/or properties, and/or interrelationships using one or more relational database management models which utilize a logic object coercion mechanism.
16. The computer-implemented method of claim 1, wherein said second ontology is implemented as a formal naming and/or definition of types and/or properties, and/or interrelationships using one or more relational database management models which utilize a logic object coercion mechanism.
17. The computer-implemented method of claim 1, wherein said first ontology is implemented as a formal naming and/or definition of types and/or properties, and/or interrelationships using one or more object oriented models which utilize a logic object coercion mechanism.
18. The computer-implemented method of claim 1, wherein said second ontology is implemented as a formal naming and/or definition of types and/or properties, and/or interrelationships using one or more object oriented models which utilize a logic object coercion mechanism.
Description
BRIEF DESCRIPTION OF THE DRAWINGS
[0019]
[0020]
[0021]
[0022]
[0023]
[0024]
[0025]
[0026]
[0027]
[0028]
[0029]
[0030]
[0031]
[0032]
DETAILED DESCRIPTION
[0033] Referring to the system overview 100 of
[0034]
[0035]
[0036]
[0037]
[0038] The described technology can also be practiced in distributed computing environments, where tasks or modules are performed by remote processing devices, which are linked through a communications network, such as a Local Area Network (“LAN”), Wide Area Network (“WAN”), or the Internet. In a distributed computing environment, program modules or subroutines may be located in both local and remote memory storage devices. Those skilled in the relevant art will recognize that portions of the described technology may reside on a server computer, while corresponding portions reside on a client computer (e.g., PC, mobile computer, tablet, or smart phone). Data structures and transmissions of data particular to aspects of the technology are also encompassed within the scope of the described technology.
[0039] Referring to
[0040] The input devices 540 may include a keyboard and/or a pointing device such as a mouse. Other input devices are possible. The storage devices 550 may include any type of computer-readable media that can store data accessible to the computer 500, such as magnetic hard and floppy disk drives, optical disc drives, magnetic cassettes, tape drives, flash memory cards, digital video disks (DVDs), Bernoulli cartridges, RAMs, ROMs, smart cards, etc. Indeed, any medium for storing or transmitting computer-readable instructions and data may be employed, including a connection port to a node on a network, such as LAN, WAN, or the Internet (not shown in
[0041]
[0042]
[0043]
[0044]
[0045] Knowledge Representation & Reasoning
[0046] The system described is termed youdobot.net, which implements a Knowledge Representation & Reasoning System. A person of ordinary skill in the relevant art will understand that the present disclosure may be implemented using other knowledge representation & reasoning systems without departing from the spirit or scope of the present disclosure.
[0047] The Knowledge Interchange Format (KIF) in a dialect of the programming language Lisp is used to specify information in a way that a knowledge representation and reasoning system may consume it. Source code shown in tables of the present disclosure employs this dialect of the Lisp programming language. Unlike a relational database, a knowledge representation and reasoning system is fundamentally optimized to define and process rules of inference. Being “optimized to define and process” is also referred to as being a “first class citizen” of an information system. In this vein, inference is a “first class citizen” of a knowledge representation and reasoning system. This leads to an important distinction from traditional database technology. With a relational database, a human must understand and reason about the database schema by formulating queries that reason about the data in the schema. If constraints are to be defined, these are embedded in queries in the form of predicates. In this knowledge representation and reasoning system, by contrast, predicates are an integral part of what would be a schema in a relational database. This gives rise to a key strength of a knowledge representation and reasoning system: The human user may directly query conclusions—without necessarily understanding or having to explicitly specify intermediate logic. This constitutes automated reasoning.
[0048] Robotic Capability Ontology
[0049] The robotic capability ontology defines a catalog or registry of robotic capabilities with a view towards assigning tasks in a sequence of manufacturing steps to individual robots. In order to do this, the system must firstly define what types of robots exist. The categorization hierarchies in tables 1 and 2 illustrate this.
TABLE-US-00001 TABLE 1 Robot Classification Hierarchy Robot Assembly Finishing Handling ShapingForming Textile Riveting Polishing Packaging Additive Sewing . . . Bonding Painting Conveying Subtractive Ironing . . . Brushing . . . . . . Injection Molding . . . Fusing . . .
TABLE-US-00002 TABLE 2 Subordinate Robot Classification Hierarchy Fusing Welding Soldering Arc Soft . . . Electron Hard Flux Induction Laser . . . Mig Plasma Spot . . .
[0050] An elaboration of how the hierarchy from table 1 may be represented in Knowledge Interchange Format is shown in table 3.
TABLE-US-00003 TABLE 3 Base Robot Concepts ;; Base Robot Concept ;;=============== (defconcept Robot (?r) :documentation “The concept of ROBOT beings”) ;; Level 2 Robot Concepts ;;================== (defconcept AssemblyRobot (?r Robot) :documentation “True if ?r assembles product components into a product”) (defconcept HandlingRobot (?r Robot) :documentation “True if ?r handles products, e.g. moving them ”) (defconcept FinishingRobot (?r Robot) :documentation “True if ?r applies a finish to products, e.g. polishing”) (defconcept ShapingFormingRobot (?r Robot) :documentation “true if ?r is a robot that shapes or forms material”) (defconcept TextileRobot (?r Robot) :documentation “true if ?r is a robot that processes textiles”)
[0051] Likewise concept categories may be refined in the hierarchy with subcategories.
TABLE-US-00004 TABLE 4 Subordinate Robot Concepts ;; Level 3 Robot Concepts ;;======================== (defconcept AdditiveRobot (?r ShapingFormingRobot) :documentation “true if ?r is an 3D printing/additive manufacturing robot”) (defconcept SubtractiveRobot (?r ShapingFormingRobot) :documentation “true if ?r is a milling, drilling, machining etc. robot”) (defconcept FusingRobot (?r ShapingFormingRobot) :documentation “true if ?r is a robot that fuses components, e.g. welding”) (defconcept SewingRobot (?r TextileRobot) :documentation “true if ?r is a robot that sews textiles”) (defconcept PackagingRobot (?r HandlingRobot) :documentation “true if ?r is a robot that packages materials”) ;; Level 4 Robot Concepts ;;======================== (defconcept WeldingRobot (?r FusingRobot) :documentation “true if ?r is a welding robot”) (defconcept BondingRobot (?r FusingRobot) :documentation “true if ?r is a robot that bonds components, e.g. gluing”)
[0052] Relations may be defined between categories.
TABLE-US-00005 TABLE 5 Robot Category Relations ;; Robot relations ;;================ (defrelation preprocessor-of ((?r1 Robot) (?r2 Robot)) :documentation “True if ?r1 is a preprocessor of ?r2”) (defrelation postprocessor-of ((?r1 Robot) (?r2 Robot)) :documentation “True if ?r1 is a postprocessor of ?r2”) (defrelation can-handle-material ((?r Robot) (?m Physical-Entity)) :documentation “True if Robot ?r can handle Physical-Entity ?m”) (defrelation can-handle-component ((?r Robot) (?c Component)) :documentation “True if Robot ?r can handle Component ?c”)
[0053] Unary relations are defined as shown below.
TABLE-US-00006 TABLE 6 Robot Unary Relations ;; Unary relations (defrelation networkable ((?r Robot)) :documentation “True if ?r is networkable”)
[0054] Characteristic of this method is the hierarchical specialization of concepts and their relational classification. At this point, it is possible to browse the robotic hierarchy in what is termed an “ontology browser.” Please refer to
[0055] We have shown the source code of the robotic capability ontology which is instrumental in a] demonstrating what is characteristic of the model and b] relating robotic capabilities to products and eventually to the Manufacturing Ontology. The robotic capability ontology has been described in terms of the Lisp dialect KIF. KIF may be entered through an interactive session by a human operator or client software or KIF may be read from one or more files and/or stored in one of more files. Alternate representations of the robotic capability ontology include reading aspects of the ontology from and storing it in a relational database or representing it in an object oriented class model. As described in paragraph [0029], relational databases are not optimized for inference. Likewise, the object oriented class model is not optimized for inference. Nevertheless, both object orientation and the relational database model may be used to persist at least part of the robotic capability ontology through a “Logic Object Coercion Mechanism.” Persons of ordinary skill in the art will know this also as “type casting.” To persist the robotic capability ontology in either a relational database or a UML class model, also referred to as an object oriented model, all types must be convertible to logic objects.
Tables 7 and 8 demonstrate the process described in
TABLE-US-00007 TABLE 7 Relational Representation of Robots - Robots represented by Character Strings mysql> show tables; +---------------------+ | Tables_in_youdobot | +---------------------+ | robot | +---------------------+ 1 rows in set (0.00 sec) mysql> describe robot; +---------+-------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +---------+-------------+------+-----+---------+-------+ | rtype | varchar(20) | YES | | NULL | | | parent | varchar(20) | YES | | NULL | | +---------+-------------+------+-----+---------+-------+ 2 rows in set (0.01 sec) mysql> select * from robot, +----------------+----------------+ | rtype | parent | +----------------+----------------+ | Robot | | | ShapingForming | Robot | | Additive | ShapingForming | | Subtractive | ShapingForming | +----------------+----------------+ 4 rows in set (0.00 sec) mysql>
TABLE-US-00008 TABLE 8 Source Code: Logic Object Coercion Mechanism - KIF Type Coercion PL-USER |= (defdb mydb :sql-database true :jdbc-connection-string ″jdbc:mysql://localhost:3306/youdobot?user=u&password=p″) |i|MYDB PL-USER |= (retrieve 4 (rdbms/query-database mydb ″select rtype from robot″ ?r)) There are 4 solutions so far: #1: ?R=|Robot| #2: ?R=|ShapingForming| #3: ?R=|Additive| #4: ?R=|Subtractive| ;; ;; Note that KIF has cast the character strings from the ;; database to logic objects, denoted by the vertical bars. ;; This is called coercion in KIF. ;; We can turn coercion off. PL-USER |= (retrieve 4 (?r string) (rdbms/query-database mydb ″select rtype from robot″ ?r)) There are 4 solutions so far: #1: ?R=”Robot” #2: ?R=”ShapingForming” #3: ?R=”Additive” #4: ?R=”Subtractive” ;; Note that KIF has now retained the native character ;; string types, denoted by the double quotes surrounding ;; ”Robot”, ”ShapingForming”, ”Additive”, and ”Subtractive”.
[0056] Manufacturing Ontology
[0057] The Manufacturing Ontology defines concepts underlying products and their manufacture. Like the Robotic Capability Ontology, the Manufacturing Ontology utilizes the Knowledge Interchange Format, KIF, but its specification encompasses concepts, relations, functions as well as full predicate calculus.
TABLE-US-00009 TABLE 9 Manufacturable Product Concepts ;; Manufacturable Product Concepts ;;================================= (defconcept Entity (?e) :documentation “The concept of an unqualified thing/matter”) (defconcept Physical-Entity (?e Entity) :documentation “A physical entity is a quantifiable entity, e.g, one with size.”) (defconcept Non-Physical-Entity (?e Entity) :documentation “A non physical entity without mass; for example, a polish.”) (defrelation part-of ((?x Physical-Entity) (?y Physical-Entity)) :documentation “True if ?x is a part of ?y.”) (defrelation aggregates ((?x Physical-Entity) (?y Physical-Entity)) :documentation “True if ?x is made up of ?y.”)
[0058] Table 9 defines entities and physical entities. We also establish that physical entities may be related by being part of or aggregating one another. It has yet to be defined what that means. For this we introduce rules of implication. The first rule combines mathematical quantification (forall) with implication (=>).
TABLE-US-00010 TABLE 10 Part-of Concept ;; Define the part-of concept ;;================================= ;; If x is a part of y then y aggregates x ;; Note that part-of is not transitive. (assert (forall ((?x Physical-Entity) (?y Physical-Entity)) (=> (part-of ?x ?y) (aggregates ?y ?x))))
[0059] What the rule in table 10 says is that any one (x) which is part of another (y), the other part (y) aggregates the one (x). Therefore “part-of” is the inverse of “aggregates” The implication is non-transitive. But aggregates can be transitive. That is how composites are created.
TABLE-US-00011 TABLE 11 Transitive Concepts ;; Transitivity: If {grave over ( )}?x′ aggregates {grave over ( )}?y′ and {grave over ( )}?y′ aggregates {grave over ( )}?z′ then {grave over ( )}?x′ aggregates {grave over ( )}?z′. ;; This is the chain rule of implication used to construct recursion. This ;; rule is recursive, since its consequent (or head) defines an ‘aggregates’ ;; relationship by recursively referencing ‘aggregates’ in its antecedent (or tail). (assert (forall ((?x Physical-Entity) (?z Physical-Entity)) (=> (exists (?y Physical-Entity) (and (aggregates ?x ?y) (aggregates ?y ?z))) (aggregates ?x ?z))))
[0060] Above we are formulating a rule based on universal quantification (forall), implication (=>) and additionally existential quantification (exists). What we are saying is that for all x and z where a y exists such that x aggregates y and y aggregates z then x also aggregates z. This means no direct relationship between x and z needs to be specified. It is now inferable—and this inference will work no matter how many intermediate aggregates connect x and z, because the rule is, in computer science terms, “recursive.”
[0061] We now proceed to distinguish between part-of and Part since at any point in time a Part, while intended for a whole, may not be part-of a whole. Further we define made-of to be single valued (axiom single-valued). This is because we will define composites separately. See tables 12 and 13.
TABLE-US-00012 TABLE 12 Made-of Concept ;; The concept of a part: We try to distinguish this from the relationship ;; part-of in that a part may not at any point in time be part of anything. ;; We call things parts that are intended to function integrated in something ;; else yet spend part of their life cycle not integrated in that something ;; else. For example, a light bulb fulfills a purpose in a lamp, but if spare ;; may exists outside of that context. Hence a part may not be “part of.” (defconcept Part (?part Physical-Entity) :documentation “A part is a thing that fulfills a greater purpose partially”) (defrelation made-of ((?p Part) (?m Physical-Entity)) :documentation “True if Part ?p is made of Physical-Entity ?m.” :axioms ((single-valued made-of)))
[0062] In table 13 we define composites to be wholes composed of more than one Part. Firstly, we define the concept of a Composite to be a specialization of Part. Secondly we define a rule, which asserts that when the cardinality of the aggregates relation involving any x is at least two (range-cardinality-lower-bound), then x is a Composite. Because Composites are Parts, x must also be a Part. The specification is shorter than it's explanation.
TABLE-US-00013 TABLE 13 Composite Concept ;; Concept of a composite: ;; must have at least two parts (defconcept Composite (?p Part)) (assert (forall ?x (=> (range-cardinality-lower-hound aggregates ?x 2) (Composite ?x))))
[0063] At last we are equipped to define the Component that we saw in the earlier section. It is hoped that the definition is intuitive. Please refer to the comments in the code.
TABLE-US-00014 TABLE 14 Component Concept ;; A Component is a part such that there exists a whole that aggregates it ;; in a way that there are at least two parts aggregated by that whole. (defconcept Component (?p Part) :documentation “A part of something; not the whole; having two or more Physical-Entities or other Components” :<=> (exists (?whole) (and (aggregates ?whole ?p) (Composite ?whole))))
[0064] It is necessary to link the Manufacturing Ontology with the Robotic Capability Ontology in order to support a use case of automated reasoning assisted product design. Individual robots have specific capabilities. For example, we defined assembly robots to include bonding, and fusing robots to include welding. These are methods to “join” parts, but we have yet to introduce that concept.
[0065] In table 15 we define the concept Join in terms of a set and define a function join-using that maps any two Components to a Join.
TABLE-US-00015 TABLE 15 Join Concept (defconcept Join (?j) :<=> (member-of ?j (setof WELD GLUE NAIL STAPLE SCREW ARTICULATED-HINGE STITCH RIVET ))) (deffunction join-using ((?x Component) (?y Component)) :->(?j Join))
[0066] We are now equipped to define the requires-materials-joined-by relation. Consider the case of a robot that can glue to support a particular Join, but which cannot glue any arbitrary two materials. Perhaps only wood can be glued onto wood, but not onto metal. This is one example of enforcing constraints. We define requires-materials-joined-by as shown in table 16.
TABLE-US-00016 TABLE 16 Requires Materials Joined By Relation (defrelation requires-materials-joined-by ((?x Part) (?m1 Physical-Entity) (?m2 Physical-Entity) (?j Join))) (assert (forall ((?whole Part) (?m1 Physical-Entity) (?m2 Physical-Entity) (?j Join)) (=> (exists ((?c1 Component) (?c2 Component)) (and (aggregates ?whole ?c1) (aggregates ?whole ?c2) (made-of ?c1 ?m1) (made-of ?c2 ?m2) (= (join-using ?c1 ?c2) ?j))) (requires-materials-joined-by ?whole ?m1 ?m2 ?j))))
[0067] What the above says is define a relation requires-materials-joined-by. Then assert that for all wholes and any two physical entities (m1 & m2) and a join (j) the following must hold true: Where two components exist, which are aggregated by the whole and are made of m1 & m2 and where the join function taking the components as arguments produces j, then what is implied is that the relation requires-materials-joined-by is true.
[0068] In the introduction we said that inference rules could be applied directly within data definitions—the “schema.” This is one example of that method.
[0069] This method becomes useful in that the definition of a product, we will see this later, as a composite forms what computer scientists call a “graph”. A query of this product using requires-materials-joined-by, then mimics what the computer science discipline of functional programming calls a “destructuring pattern match.” The pattern match “parses” the product structure, the graph, and produces results satisfying the pattern, here a relation. Unlike in a conventional programming language, no additional code needs to be written to actively perform this pattern match within a function. Rather, the conclusions of the computation may be queried directly.
[0070] In this way, we are able to unify aspects of object orientation (hierarchical specialization), functional programming (pattern-match-style graph-destructuring), relational database concepts (relations) and rules of logic (predicate calculus) into one holistic model that enables automated reasoning. As described in paragraph [0037] with respect to the Robotic Capability Ontology, particular aspects of the Manufacturing Ontology may likewise be persisted (stored in and/or read form) using a class model or a relational model based representation.
[0071] Materials are defined as shown in table 17.
TABLE-US-00017 TABLE 17 Example Materials Defined ;;=================== ;; Materials List ;;=================== (assert (Physical-Entity plastic)) (assert (Physical-Entity wood)) (assert (Physical-Entity paper)) (assert (Physical-Entity cardboard)) (assert (Physical-Entity steel)) (assert (Physical-Entity glass)) (assert (Physical-Entity rubber) (assert (Physical-Entity brass))
[0072] We are now ready to link robots to materials they can handle and link assembly robots, in particular, to join methods they support.
[0073] Product definitions are now possible in terms of the ontology we have established. In this method, products form what is called a “directed graph” defining their components, any materials used and means of assembly.
[0074] We begin by asserting materials, plastic and wood as well as defining Parts case and lid towards construction of a box.
TABLE-US-00018 TABLE 18 Example Product Materials and Associated Parts (assert (Physical-Entity plastic)) (assert (Physical-Entity wood)) (assert (Part case)) (assert (Part lid))
[0075] Now we define the materials of which case and lid are made.
TABLE-US-00019 TABLE 19 Example Product Materials Continued (assert (made-of case plastic)) (assert (made-of lid wood))
[0076] Next we define the box. This builds our product as a directed graph.
TABLE-US-00020 TABLE 20 Example Product Definition as Directed Graph (assert (Part box)) (assert (part-of lid box)) (assert (part-of case box))
[0077] Lastly, for our limited example, we define the method of construction.
TABLE-US-00021 TABLE 21 Example Product Method of Construction (assert (= (join-using case lid) ARTICULATED-HINGE))
[0078] An articulated hinge joins case and lid.
[0079] We may now browse our knowledge base in an ontology browser. The illustration below shows navigating to the Part entity and browsing box, case and lid. The “Propositions for Box” pane shows what a box is. It is a part. Case and lid are its parts. Please refer to
[0080] Likewise we may query what is part of a box programmatically:
TABLE-US-00022 TABLE 22 Querying Product Components STELLA> (retrieve all (?x) (aggregates box ?x)) ;There are 2 solutions: ;#1: ?X=CASE ;#2: ?X=LID
[0081] Automated Reasoning
[0082] We can also ask the system to reason about our box. One thing we have not explicitly stated is whether a box is a Composite. But recall that our definition of Composite was an aggregate with 2 or more parts. If one needs to know, one can simply issue the (why) command.
TABLE-US-00023 TABLE 23 Explaining Propositions STELLA> (ask (Composite box)) TRUE STELLA> (why) 1 (COMPOSITE BOX) follows by Modus Ponens with substitution {?x/BOX} since 1.1 ! (FORALL (?x) (<= (COMPOSITE ?x) (RANGE-CARDINALITY-LOWER-BOUND AGGREGATES ?x 2))) and 1.2 (RANGE-CARDINALITY-LOWER-BOUND AGGREGATES BOX 2) 1.2 (RANGE-CARDINALITY-LOWER- BOUND AGGREGATES BOX 2) follows by Modus Ponens with substitution {?v05/2, ?lb/2, ?i/BOX, ?r/AGGREGATES} since 1.2.1 ! (FORALL (?r ?i ?lb) (<= (RANGE-CARDINALITY-LOWER-BOUND ?r ?i ?lb) (EXISTS (?v05) (AND (BOUND-VARIABLES ?r ?i ?lb) (= (RANGE-MIN-CARDINALITY ?r ?i) ?v05) (=< ?lb ?v05))))) and 1.2.2 (BOUND-VARIABLES AGGREGATES BOX 2) and 1.2.3 (= (RANGE-MIN-CARDINALITY AGGREGATES BOX) 2) and 1.2.4 (=< 2 2) ...
[0083] As the excerpt shows, we may even ask the system to explain why it thinks that a box is a Composite. The astute mathematician will note that part of the proof has been elided. Enough of the full proof has been shown to demonstrate the reasoning capabilities of the system.
[0084] Most importantly, we want to know how to build our box. What materials will need to be joined onto what others and how?
TABLE-US-00024 TABLE 24 Querying Product Materials and Means of Construction STELLA> (retrieve all (?m1 ?m2 ?j) (requires-materials-joined-by box ?m1 ?m2 ?j)) There is 1 solution: #1: ?M1=PLASTIC, ?M2=WOOD, ?J=ARTICULATED-HINGE
[0085] The “retrieve all” command has triggered the parsing of the product graph for box and all relations satisfying the requires-materials-joined-by predicate have been identified. Free variables m1, m2, j have been filled in. Of interest is the “SQL style” declarative nature of this command. Yet there are no data tables. Instead, a graph based data structure has been parsed and processed—a task familiar to computer programmers as procedural rather than declarative. Traditionally this is where computer programmers spend and lose their development time: Data structures are defined—declaratively. Then procedural algorithms are constructed to parse and process them. Finally, the data model changes and the algorithms must be re-written—or vise versa. Likewise, in a data driven model, such as a relational database, stored procedures assume the role of the algorithm. This disjoin requires a human domain expert to use understanding of the data model & algorithm. This understanding is codified in procedures, which themselves cannot be reasoned about algebraically. The esteemed mathematician E. W. Dijkstra called this “operational reasoning” and considered it “to be one of the main causes of the persistence of the software crisis.” The technology described in the present disclosure solves this problem.
[0086] Characteristic of the implementation we have presented here is that concepts are described in terms of predicate calculus and that relational and functional concepts are integrated in a way that the system can reason about itself. Computations are produced without explicitly traversing and parsing the data model.
[0087] Deducing Manufacturing Plans
[0088] Robot definitions allow connecting knowledge of how to build products to deducing manufacturing plans. We begin by defining robots.
TABLE-US-00025 TABLE 25 Example Robot Definitions ;;========================= ;; Sample Robot Definitions ;;========================= ;; A 3D Printer, not otherwise qualified (assert (Robot 3dprinter)) ;; A box assembly robot that can handle wood, plastic and steel ;; using hinges, rivets and staples (assert (AssemblyRobot boxmakerbot)) (assert (can-handle-material boxmakerbot wood)) (assert (can-handle-material boxmakerbot plastic)) (assert (can-handle-material boxmakerbot steel)) (assert (can-join-using boxmakerbot ARTICULATED-HINGE)) (assert (can-join-using boxmakerbot RIVET)) (assert (can-join-using boxmakerbot STAPLE)) ;; WhoIsBaxter (assert (HandlingRobot whoisbaxter)) ; WhoIsBaxter is versatile (assert (FinishingRobot whoisbaxter)) ; Illustration given to show that (assert (AssemblyRobot whoisbaxter)) ; multiple categorizations are allowed ;; A fusing robot that can glue components (assert (FusingRobot stickerbot)) (assert (can-handle-material stickerbot wood)) (assert (can-handle-material stickerbot brass)) (assert (can-join-using stickerbot GLUE))
[0089] We have already seen the relation requires-materials-joined-by. We modify this slightly to accommodate robots and define the requires-materials-joined-by-robot.
TABLE-US-00026 TABLE 26 Mapping Means of Construction onto Robots ;; Define requires-materials-joined-by-robot relation (defrelation requires-materials-joined-by-robot ((?x Part) (?m1 Physical-Entity) (?m2 Physical-Entity) (?j Join) (?r Robot))) (assert (forall ((?whole Part) (?m1 Physical-Entity) (?m2 Physical-Entity) (?j Join) (?r Robot)) (=> (exists ((?c1 Component) (?c2 Component)) (and (aggregates ?whole ?c1) (aggregates ?whole ?c2) (made-of ?c1 ?m1) (made-of ?c2 ?m2) (= (join-using ?c1 ?c2) ?j) (can-handle-material ?r ?m1) (can-handle-material ?r ?m2) (can-join-using ?r ?j) )) (requires-materials-joined-by-robot ?whole ?m1 ?m2 ?j ?r))))
[0090] Feasibility Analysis
[0091] Before we asked what materials will need to be joined onto what others and how? Now it is possible to ask what robot can provide this service to establish if the design is feasible. If there are no solutions, the design is not feasible. If the query finds solutions, the design is feasible.
TABLE-US-00027 TABLE 27 Querying Robots Required to Construct a Product STELLA> (retrieve all (?m1 ?m2 ?j ?r) (requires-materials-joined-by-robot box ?m1 ?m2 ?j ?r)) There is 1 solution: #1: ?M1=PLASTIC, ?M2=WOOD, ?J=ARTICULATED-HINGE, ?R=BOXMAKERBOT
[0092] Our design is feasible. We will require the “boxmakerbot” robot. It is worth noting that this automated exploration of feasibility supports not only queries by human operators, but also permits software assisted product design. Thus, where traditionally supply models utilized a strategy bringing branded products to consumers, the method presented here is designed to support a pull supply chain model that sees bespoke products composed from capabilities. Manufacturers become vendors of capabilities. See overleaf for more manufacturing plans.
[0093] The next paragraph is intended to show how compositional the system is and to demonstrate the concept of a manufacturing plan. A manufacturing plan details what robots are needed to complete a product requiring multiple manufacturing steps—and possibly the order of steps. The steps below illustrate an elaboration of the box design. [0094] Define a plaque; [0095] Make it from brass. [0096] Then add it to the box and [0097] glue it to the lid.
[0098] Shown below is our definition.
Note how the “code” models the structure of the English description that we just gave.
TABLE-US-00028 TABLE 28 Extending the Example Product Definition (assert (Part plaque)) (assert (made-of plaque brass)) (assert (part-of plaque box)) (assert (= (join-using lid plaque) GLUE))
[0099] Finally, we ask the system to produce a manufacturing plan.
TABLE-US-00029 TABLE 29 Computing a Manufacturing Plan STELLA> (retrieve all (?m1 ?m2 ?j ?r) (requires-materials-joined-by-robot box ?m1 ?m2 ?j ?r)) There are 2 solutions: #1: ?M1=WOOD, ?M2=BRASS, ?J=GLUE, ?R=STICKERBOT #2: ?M1=PLASTIC, ?M2=WOOD, ?J=ARTICULATED-HINGE, ?R=BOXMAKERBOT
[0100] Non Physical Entities
[0101] We can easily extend the model to add processing steps that include non-physical entities. We never mentioned why materials are modelled as physical entities—to allow them to be composed transparently with manufacturing steps involving non physical entities. For example we might imagine that the brass plate would be “composed” with a polish. In that case, the polish is a non physical entity (one without mass) that is applied to the brass plate. We define as follows:
TABLE-US-00030 TABLE 30 Non Physical Entities (defconcept Non-Physical-Entity (?e Entity) :documentation “A non physical entity without mass; for example a polish.”) (assert (Non-Physical-Entity polish))
[0102] Quantitative Reasoning & Satisficing
[0103] Discrete reasoning systems are powerful, but are plagued by the fact that real world data is often quantitative rather than qualitative. In our previous example, an entity could be either physical or non-physical. This is a discrete quality ascribed to entities in our ontology. Much of our world is described differently. Weather can be good or bad. This too is qualitative. But the goodness or badness of weather exists on a continuum. Temperature is measured in degrees. Precipitation is measured in terms of volume. Sunshine is measured in hours per day. This continuous data is also termed “quantitative.” For any day we may have some of this information—but not necessarily all—and our information may be imprecise or contradictory. The way humans arrive at actionable conclusions is termed “satisficing,” This process discerns what is statistically relevant in economic terms from what is not. To do this we have to combine qualitative reasoning with quantitative reasoning.
[0104] The method described here integrates quantitative logic with the discrete logic of predicate calculus to facilitate decision-making based on incomplete and continuous data.
[0105] The example below uses the concept of Meantime Between Failure (MBF) of products and parts as an illustration.
[0106] We begin by defining a statistically meaningful sample population—an excerpt is shown in table 31.
TABLE-US-00031 TABLE 31 Sample Population ;; A parts sample population (assert (Part axle)) (assert (Part bearing)) (assert (Part belt)) (assert (Part box)) (assert (Part bracket)) (assert (Part buckle)) (assert (Part bulb)) (assert (Part bushing)) (assert (Part button)) (assert (Part canvas)) (assert (Part cart)) (assert (Part case)) (assert (Part chain)) (assert (Part cylinder)) (assert (Part drawer)) (assert (Part driveshaft)) ...
[0107] We also define the concepts of Meantime Between Failure (MBF) and “HeavyDuty” construction.
TABLE-US-00032 TABLE 32 Meantime Between Failure Defined ; Define function Meantime Between Failure (deffunction mbf ((?p Part)) :−> (?i float) :documentation “Meantime between failure of a part in months”) ; Unary relation HeavyDuty (defrelation heavyduty ((?p Part)) :documentation “Parts advertisied by manufacturer as heavy duty”)
[0108] Meantime Between Failure (MBF) in our model is TOTAL failure. Therefore a dresser with drawers where each drawer has a handle is not deemed to have failed in total if one handle breaks. A handle on its own that breaks suffers total failure, as it is no longer usable. Therefore a composite with multiple components will likely have a longer MBF than its components alone. We anticipate manufacturer advertisings to have a mixed impact on MBF.
[0109] An excerpt of sample data for parts is shown below.
Note that this data is purely fictional and for illustration purposes only.
TABLE-US-00033 TABLE 33 Meantime Between Failure Sample Data (assert (mbf axle 12.3)) (assert (mbf bearing 46.0)) (assert (mbf belt 19.2)) (assert (mbf box 48.0)) (assert (mbf bracket 13.7)) (assert (mbf buckle 12.4)) (assert (mbf bulb 25.2)) (assert (mbf bushing 10.9)) (assert (mbf button 19.8)) (assert (mbf canvas 12.3)) (assert (mbf cart 77.4)) (assert (mbf case 23.0)) (assert (mbf chain 8.3)) (assert (mbf cylinder 12.5)) (assert (mbf drawer 25.2)) (assert (mbf driveshaft 14.6)) ...
[0110] We will assume that composite product definitions are entered in the model as shown before.
[0111] We may now proceed to reason about parts for which we are missing Meantime Between Failure data. For this we will use an integrated neural network. Our neural network will be trained on MBF sample data and the propositional properties of Parts. For our purposes these will be the “part-of” and the “heavyduty” relations.
TABLE-US-00034 TABLE 34 Machine Learning Configuration ;; Define Neural Network (set-error-print-cycle 1) (set-partial-match-mode :nn) (set-neural-network-training-method :BACKPROP) (set-learning-rate 0.2) (set-momentum-term 0.8) ;; Define regression module which will learn to ;; predict the age of a person based on a person's structural ;; properties. 50 training cycles. (structured-neural-network-regression part mbf 50)
[0112] We define a new part and enquire about its predicted MBF.
TABLE-US-00035 TABLE 35 Regression Based Prediction STELLA> (assert (Part unknownPart)) STELLA> (approximate unknownPart Mbf) ANSWER> 17.976807290601176
[0113] Based on everything we know about parts in general, just knowing that unknownPart is a Part yields a prediction of 17.97 months meantime between failure. This is essentially in line with the central tendency for MBF in our sample data. How would this prediction change if we knew that its manufacturer classed the unknownPart as heavy duty? The system permits a direct and ad-hoc analysis of this question.
TABLE-US-00036 TABLE 36 Machine Learning Feature Selection STELLA> (assert (HeavyDuty unknownPart)) |P|(HEAVYDUTY UNKNOWNPART) STELLA> (approximate unknownPart Mbf) ANSWER> 18.89186548264741
[0114] Apparently the impact is negligible—for this data model. This mechanism allows ad-hoc selection of features that are relevant to our model—traditionally a difficult task.
[0115] Deductive Quantitative Reasoning
[0116] The following paragraphs explore how being a “Composite” impacts the MBF prediction. Three components are created and designated parts of the “unknownPart,” thus rendering “unknownPart” a composite. How is the MBF prediction affected?
TABLE-US-00037 TABLE 37 Machine Learning Feature Selection Continued STELLA> (assert (Part componentA)) STELLA> (assert (Part componentB)) STELLA> (assert (Part componentC)) STELLA> (assert (part-of componentA unknownPart)) STELLA> (assert (part-of componentB unknownPart)) STELLA> (assert (part-of componentC unknownPart)) STELLA> (approximate unknownPart Mbf) ANSWER> 48.83258616830254
[0117] The predicted part-of relation is transitive. It stands to reason that in a composite with a breadth of MBF has increased substantially reflecting the composite structure. What happens if we have a chain of components with subcomponents? Recall that the components (e.g. a dresser with many drawers) improves its Meantime Between Failure through many components, but that the inverse is true for a long and narrow chain of components. Any link in the chain can induce failure. This is modelled as follows.
TABLE-US-00038 TABLE 38 Machine Learning Feature Inference STELLA> (assert (Part componentAA)) STELLA> (assert (Part componentBB)) STELLA> (assert (Part componentCC)) STELLA> (assert (part-of componentAA componentA)) STELLA> (assert (part-of componentBB componentB)) STELLA> (assert (part-of componentCC componentC)) STELLA> (approximate unknownPart Mbf) ANSWER> 31.72638230248698
[0118] The outcome is as we predicted. A chain of subcomponents adversely affects reliability. But note how we said nothing new about “unknownPart” at all. The system has inferred the result through reasoning about the transitive relation “part-of” alone. Also note once more how the analysis is both ad-hoc and immediate. In a mainstream model of computation there would typically have been inter-process communication between the computation and a database or a statistical analysis system, followed by the return of the analytical results for evaluation. Here results are immediate because analysis, database and computation are integrated.
[0119] Visual Modeling
[0120] Visual Programming assists non-technical users in approaching complex domain expertise. The technique is frequently used in elementary schools to introduce children to computer programming: Children model sprites in an editor that is analogous to a game simulator. This paradigm also resonates with modeling of toy robotics and their movements through a scene. The approach presented here extends the concept of sprites moving through a scene to the concept of parts moving through a supply chain and products being described in terms of the steps of their manufacture. Block-oriented lexical constructs are mapped to the Lisp based syntax and semantics in PowerLoom and its Knowledge Interchange Format KIF, allowing only blocks to be connected that result in syntactically correct constructs. Please refer to
[0121]
[0122]