Incorporating rules into complex automated decisions
Through the generation-filter-select decision-making process and an interchangeable action rule system, combined with automatic root cause analysis, the problems of object identity determination and resource consumption in complex automated decision-making are solved, and safe and efficient decision-making processing is achieved.
Patent Information
- Application Number
- CN202411148732.5
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Priority Date
- 2019-07-15
- Filing Date
- 2019-07-16
- Publication Date
- 2024-12-03
AI Technical Summary
The prior art lacks an effective set of rules to determine object identities in complex automated decision-making, especially in autonomous vehicles and image recognition applications, resulting in possible poor decision-making based on heuristics and statistical inference methods, and traditional rules-based systems There are challenges in complexity and resource consumption.
Using Generation-Filter-Select Decision Process (GFSDP), combined with an interchangeable Action Rule System (CARBS) and Automatic Root Cause Analysis (ARCA), filtering and selecting appropriate decisions by generating sets of potential decisions, avoiding conflict resolution, and utilizing Three-way fault scenario analysis to identify the root cause.
Safe and wise decision-making is achieved, resource consumption is reduced, decision-making efficiency is improved, bad decision-making is avoided, and a fast and safe response is ensured in a dynamic environment.
Smart Images

Figure CN119067216A_ABST
Abstract
Description
[0001] Cross-references to other applications This application is a divisional application of application number: 201980055996.7, and the method name is “INCORPORATING RULES INTO COMPLEX AUTOMATED DECISION MAKING”. This application claims priority to U.S. Provisional Patent Application No. 62 / 698,672, filed on July 16, 2018, entitled INCORPORATING RULES INTO COMPLEX AUTOMATED DECISION MAKING, which is incorporated herein by reference for all purposes. Background Art
[0002] Automated decision making occurs in a variety of applications. As a simple example, a heating system may need to decide whether to turn on the furnace. In this simple example, a simple rule can be specified as: "If the temperature is below the configured temperature, then turn on the furnace, otherwise don't." The rule can be further elaborated to specify hysteresis, so the furnace does not turn on and off rapidly around the configured temperature. However, using traditional rules to implement complex automated systems (such as autonomous vehicles) has proven to be challenging due to the large number of variables involved in making decisions. BRIEF DESCRIPTION OF THE DRAWINGS
[0003] Various embodiments of the invention are disclosed in the following detailed description and accompanying drawings.
[0004] Figure 1 is a functional diagram illustrating a programmed computer / server system for incorporating rules into complex automated decisions according to some embodiments.
[0005] Figure 2 is a flow chart illustrating an embodiment of a process for making traditional complex automated decisions using a rule-based system.
[0006] Figure 3 is a flow chart illustrating an embodiment of a process for generating a filter selection decision process.
[0007] Figure 4 is a flow chart illustrating an embodiment of a process for CARBS execution.
[0008] Figure 5A is a flow chart illustrating an embodiment of a process for an ARCA-based decision processing sequence.
[0009] Figure 5B is a graphical representation of the failure scenario vector for the symptom.
[0010] Figure 5C is a graphic representation of a root cause table.
[0011] Figure 5Dis a diagram of a 64-bit block representation of known bits and value bits.
[0012] Figure 5E is a graphic representation of the root cause analysis technique.
[0013] Figure 6 is a flow chart illustrating an embodiment of a process for an ARCA-based autonomous driving processing sequence.
[0014] Figure 7 is a flow chart illustrating an embodiment of a process for an ARCA-based sensor interpretation processing sequence.
[0015] Figure 8 is a flow chart illustrating an embodiment of a process for an ARCA-based sensor fusion processing sequence.
[0016] Fig. 9 is a flow diagram illustrating an embodiment of a process for incorporating rules into complex automated decisions. DETAILED DESCRIPTION
[0017] The present invention may be implemented in a variety of ways, including as a process; an apparatus; a system; a composition of matter; a computer program product embodied on a computer-readable storage medium; and / or a processor, such as a processor configured to execute instructions stored on and / or provided by a memory coupled to the processor. In this specification, these embodiments or any other form that the present invention may take may be referred to as techniques. In general, the order of steps of the disclosed processes may be changed within the scope of the present invention. Unless otherwise stated, components such as processors or memories described as being configured to perform tasks may be implemented as general components that are temporarily configured to perform tasks at a given time or as specific components manufactured to perform the task. As used herein, the term "processor" refers to one or more devices, circuits, and / or processing cores configured to process data such as computer program instructions.
[0018] A detailed description of one or more embodiments of the present invention is provided below together with the accompanying drawings illustrating the principles of the present invention. The present invention is described in conjunction with such embodiments, but the present invention is not limited to any embodiment. The scope of the present invention is limited only by the claims, and the present invention encompasses many alternatives, modifications and equivalents. Many specific details are set forth in the following description in order to provide a thorough understanding of the present invention. These details are provided for illustrative purposes, and the present invention can be practiced according to the claims without some or all of these specific details. For the purpose of clarity, technical materials known in the technical field related to the present invention are not described in detail so that the present invention is not unnecessarily unclear.
[0019] Traditional Complex Automated Decision Making. In addition to the thermostat example given above, some applications have complex decision-making requirements. For example, in an autonomous vehicle (AV), once the desired destination is specified, a decision can be made automatically about the route the vehicle will follow. However, this decision is actually made up of a large number of component decisions such as when to change lanes, when to stop, etc., taking into account other vehicles and obstacles on the route. In addition, various obstacles along the route may dynamically appear and leave as well as change their own trajectories, requiring adjustments to the actual path being followed. This means that various decisions and / or sub-decisions may have to be evaluated and / or re-evaluated multiple times. In addition, these decisions may be made with respect to future scenarios generated by the dynamics of the AV and the surrounding environment (including other vehicles, pedestrians, and other obstacles). For example, the AV may detect a potential collision well in advance in order to take corrective action and / or maintain a "safe situation" (in the terminology of the Responsibility Sensitive Safety (RSS) framework developed by Mobileye / Intel).
[0020] As another example in this area, as part of this decision making, the AV may identify different types of objects present in the environment to determine how to react to them. For example, a front-facing camera may detect a large dark object directly in front of a vehicle on a highway on which the vehicle is traveling. If this dark object is the shadow of an overpass, then the AV trajectory does not need to be changed. However, if this dark object is a stalled vehicle, then the AV should initiate immediate emergency braking and / or evasive maneuvers.
[0021] Currently, there is a lack of algorithmic processes for deciding the identity of an object from an image. For example, there is no clear set of rules to determine from an image whether it is a shadow or a stalled vehicle or something else. Therefore, the current popular approach is to use so-called "machine learning" techniques, whereby a system is trained through a large set of training data to identify objects from images based essentially on statistical inference. In this approach, the identification of an object is essentially a probabilistic decision based on parameters adjusted from the training set data.
[0022] That is, there are rules that still apply when the object is a shadow, and other rules that apply when the object is a stalled vehicle. For example, a rangefinder sensor may not be sure of the distance to a shadow, while it may get a reading from a stalled vehicle. Similarly, a stalled vehicle has some minimum height, while a shadow has zero height. Thus, the rules may reject certain interpretations of the image from the machine learning-based image processing module, even though the rules may not initially identify the object from the image. In the above example, if the other sensors determine the height to be non-zero, the height rule may reject the interpretation of the image as a shadow on the highway. Thus, the rules can improve decisions based entirely on heuristics and / or statistical inference.
[0023] Figure 1 is a functional diagram illustrating a programming computer / server system for incorporating rules into complex automated decision making according to some embodiments. As shown, according to some embodiments, Figure 1 Provided is a functional diagram of a general purpose computer system that is programmed to provide for incorporating rules into complex automated decision making. As will be apparent, other computer system architectures and configurations may be used to incorporate rules into complex automated decision making.
[0024] The computer system 100, including various subsystems described below, includes at least one microprocessor subsystem, also referred to as a processor or central processing unit ("CPU") (102). For example, the processor (102) may be implemented by a single-chip processor or by multiple cores and / or processors. In some embodiments, the processor (102) is a general-purpose digital processor that controls the operation of the computer system 100. Using instructions retrieved from the memory (110), the processor (102) controls the receipt and manipulation of input data, as well as the output and display of data on output devices, such as a display and a graphics processing unit (GPU) (118).
[0025] The processor (102) is bidirectionally coupled to a memory (110), which may include a first main storage device, typically a random access memory ("RAM"), and a second main storage area, typically a read-only memory ("ROM"). As is well known in the art, the main storage device can be used as a general storage area as well as a high-speed scratch pad memory, and can also be used to store input data and processed data. The main storage device can also store programming instructions and data in the form of data objects and text objects, in addition to other data and instructions for processes operating on the processor (102). As is also well known in the art, the main storage device typically includes basic operating instructions, program code, data, and objects, such as programming instructions, used by the processor (102) to perform its functions. For example, depending on whether data access needs to be bidirectional or unidirectional, the main storage device (110) may include any suitable computer-readable storage medium described below. For example, the processor (102) can also directly and very quickly retrieve frequently needed data and store it in a cache memory not shown. The processor (102) may also include co-processors (not shown) as supplemental processing components to assist the processor and / or the memory (110).
[0026] The removable mass storage device (112) provides additional data storage capacity for the computer system 100 and is coupled to the processor (102) bidirectionally (read / write) or unidirectionally (read-only). For example, the storage device (112) may also include computer readable media such as flash memory, portable mass storage devices, holographic storage devices, magnetic devices, magneto-optical devices, optical devices, and other storage devices. The fixed mass storage device (120) may also provide additional data storage capacity, for example. An example of a mass storage device (120) is an eMMC or microSD device. In one embodiment, the mass storage device (120) is a solid-state drive connected by the bus (114). The mass storage devices (112), (120) typically store additional programming instructions, data, etc. that are not normally actively used by the processor (102). It will be understood that if desired, the information retained in the mass storage devices (112), (120) can be incorporated as part of the main storage device (110) (e.g., RAM) in a standard manner as virtual memory.
[0027] In addition to providing access to the storage subsystem to the processor (102), the bus (114) may also be used to provide access to other subsystems and devices. As shown, these may include a display monitor (118), a communication interface (116), a touch (or physical) keyboard (104), and one or more auxiliary input / output devices (106) including an audio interface, a sound card, a microphone, an audio port, an audio recording device, an audio card, a speaker, a touch (or pointing) device, and / or other subsystems as needed. In addition to a touch screen and / or a capacitive touch interface, the auxiliary device (106) may be a mouse, a stylus, a trackball, or a tablet device and is used to interact with a graphical user interface.
[0028] The communication interface (116) allows the processor (102) to be coupled to another computer, computer network, or telecommunication network using a network connection as shown. For example, through the communication interface (116), the processor (102) can receive information (e.g., data objects or program instructions) from another network during the execution of the method / process steps, or output information to another network. Information, typically represented as a sequence of instructions to be executed on the processor, can be received from another network and output to another network. An interface card or similar device and appropriate software implemented by the processor (102) (e.g., executed by / on the processor (102)) can be used to connect the computer system 100 to an external network and transfer data according to a standard protocol. For example, various process embodiments disclosed herein can be executed on the processor (102), or can be combined with a remote processor that shares a portion of the processing, and can be executed across a network such as the Internet, an intranet network, or a local area network. Throughout this specification, "network" refers to any interconnection between computer components, including the Internet, Bluetooth, WiFi, 3G, 4G, 4GLTE, GSM, Ethernet, TCP / IP, Intranet, Local Area Network ("LAN"), Home Area Network ("HAN"), Serial Connection, Parallel Connection, Wide Area Network ("WAN"), Fiber Channel, PCI / PCI-X, AGP, VLbus, PCI Express, Expresscard, Infiniband, ACCESS.bus, Wireless LAN, HomePNA, Fiber Optic, G.hn, Infrared Network, Satellite Network, Microwave Network, Cellular Network, Virtual Private Network ("VPN"), Universal Serial Bus ("USB"), FireWire, Serial ATA, l-Wire, UNI / O, or any form of connecting homogeneous, heterogeneous systems and / or groups of systems together. Additional mass storage devices not shown may also be connected to processor (102) via communication interface (116).
[0029] An auxiliary I / O device interface (not shown) may be used in conjunction with the computer system 100. The auxiliary I / O device interface may include general and customized interfaces that allow the processor (102) to send data and more generally receive data from other devices such as microphones, touch-sensitive displays, transducer card readers, tape readers, voice or handwriting recognizers, biometric readers, cameras, portable mass storage devices, and other computers.
[0030] In addition, various embodiments disclosed herein further relate to a computer storage product with a computer-readable medium, which includes program codes for performing various computer-implemented operations. A computer-readable medium is any data storage device that can store data that can be subsequently read by a computer system. Examples of computer-readable media include, but are not limited to, all of the media mentioned above: flash media such as NAND flash, eMMC, SD, compact flash; magnetic media such as hard disks, floppy disks, and tapes; optical media such as CD-ROM disks; magneto-optical media such as optical disks; and specially configured hardware devices such as application-specific integrated circuits ("ASICs"), programmable logic devices ("PLDs"), and ROM and RAM devices. Examples of program codes include both: machine code such as generated by a compiler, or files containing higher-level code (such as scripts) that can be executed using an interpreter.
[0031] Figure 1 The computer / server system shown in is only an example of a computer system suitable for use with the various embodiments disclosed herein. Other computer systems suitable for such use may include additional or fewer subsystems. In addition, the bus (114) is illustrative of any interconnection scheme for linking subsystems. Other computer architectures with subsystems in different configurations may also be utilized.
[0032] Figure 2 is a flow chart illustrating an embodiment of a process for performing traditional complex automated decision making using a rule-based system (RBS). In one embodiment, Figure 2 The flowchart is as follows Figure 1 In one embodiment, Figure 2 The flowchart is a traditional RBS execution flow. In the past, rule-based systems have been used for complex automated decision making, such as in artificial intelligence applications. These systems typically structure rules as "condition: action", where the condition (202) indicates the conditions that must be true for this rule to be applied, and the action (206) is the processing to be performed when the rule is to be applied.
[0033] As an example of a traditional RBS, consider a system with four components: a rule base as a knowledge base type, including a list of rules; a temporary working memory, a user interface, and an inference engine to take actions based on the interaction of inputs and the rule base. In a traditional RBS, this inference engine includes a traditional match-parse-act cycle to match inputs to rules, perform conflict resolution between matched rules, and act on the resolved rules.
[0034] For example, in navigation, a rule may be specified as: condition "if the vehicle is approaching a red light" (202), then action "stop and wait for the light to turn green" (206). However, in complex applications such as autonomous driving, the rules may end up being much more complex. For example, it is important to recognize that the vehicle should stop behind any vehicle in front of it and not proceed on a green light until the other vehicles have also given it enough space to proceed safely. Furthermore, if the intersection is still blocked by other cars, the vehicle should not proceed on a green light even if it is the first car at the intersection.
[0035] Typically, as described above, traditional rule-based systems can quickly become extremely complex to develop, understand, and maintain, and expensive to implement. In particular, if multiple conditions become true, there is a need for a conflict resolution strategy to decide which action to execute first (204). In addition, once a selected rule has caused its associated action to be executed (206), it is possible that one or more previous rules whose conditions were matched no longer actually match due to the action according to the first rule. For the same reason, conditions associated with other rules may now match. Therefore, the RBS needs to rematch the conditions (202) after each rule execution (206). In the case of a complex set of rules and conditions, it may be necessary to repeat the conflict resolution (204) and rematch (202 to 206) multiple times, thereby significantly increasing the processing, memory, network and / or resource costs of each rule execution. In addition, these traditional RBSs may be "fragile" in the sense that the rules may be too rigid or insufficient in unfamiliar situations.
[0036] That is, complex applications based entirely on heuristics and statistics (e.g., machine learning applications) can make poor decisions in some cases, as demonstrated by several AV / autonomous vehicle accidents where the system made poor decisions in certain confusing situations. For example, in one case, the vehicle accelerated just before hitting a guardrail, violating a basic rule of driving, which is: if you are confused about a situation, slow down. Similarly, machine learning-based image recognition has been confused and produced clearly wrong interpretations in some cases (when the image is not entirely within the training set on which it has been trained).
[0037] Generate-filter-select complex automated decisions.
[0038] Disclosed is a method of merging rules that ensure safe and / or constrained behavior and smart decisions with automated complex decisions, while avoiding known difficulties in previous rule-based approaches and providing efficient decisions. In some embodiments, a decision process is disclosed that includes a generation phase, a filtering phase, and a selection phase.
[0039] Figure 3 is a flow chart illustrating an embodiment of a process for a generate-filter-select decision process. Figure 3 In the example, there is a generation phase (302) in which a set of potential decisions for a given scenario, i.e., a potential decision set (PDS), is generated. In the filtering phase (304), entries in the PDS are tested against rules that may cause entries to be deleted, re-ranked in importance, and / or re-evaluated / modified. In one embodiment, the filter is used in (304). Figure 2 The process of filtering is similar to that of filtering, but the conflict resolution in (204) is not required in the filtering phase. In the selection phase (306), the remaining entries in the PDS are selected by some criteria (usually some cost function). This three-phase sequence is referred to herein as the Generate-Filter-Select Decision Process or "GFSDP".
[0040] For example, in the case of an autonomous vehicle, in the generation phase (302), a set of possible navigation plans from the current location to the desired destination is generated. In one embodiment, the navigation plan may include the direction / path to be taken by the vehicle, instructions for driving, accelerator, brakes, etc. of the vehicle. The set may be generated by various conventional techniques. As an alternative, multiple paths, such as a series of waypoints, from the current location to the desired destination may be generated using standard path-finding automatic navigation techniques such as those used in current car navigation products. In another area (such as determining the potential interpretation of an image), a machine learning approach may be used to generate the set, which is sorted by probability / confidence. In another case, random generation may be used to explore the possibility of outliers. A mixture of these methods may be used simultaneously.
[0041] The set of possible navigation plans includes one or more entries. In the filtering stage (304), RBS is used to identify problems with zero or more entries in the set. In particular, depending on the degree and nature of the match, any entry that triggers one or more rules specified in the rule-based system is considered to have problems, optionally with varying degrees of problems. That is, the rules can tell an individual (one) what it is not, rather than what it is. Then, entries with such identification problems can be opposed (such as removed, corrected, deprioritized, etc.), thereby improving the final decision output.
[0042] For example, a set of navigation plans includes a first driving plan that turns the vehicle right onto a street into the rightmost lane of the street and a second driving plan that turns right into the middle lane of the street. The first driving plan may be determined to match a rule that enters a "dangerous situation" with another vehicle because another vehicle is parked in the lane, where a "dangerous situation" is defined in RSS or other safety frameworks. Therefore, that plan is eliminated and / or marked for modification, and the second plan that makes a right turn into the middle lane of the street is retained and becomes the preferred plan. Although the first plan is the preferred plan in the absence of obstacles, it is replaced by the second plan in this case due to the presence of other vehicles. The end result is an improved decision compared to using the highest priority or lowest cost plan provided by the generation phase.
[0043] A driving plan is then selected from the remaining entries in the PDS (306), typically based on some measure of "goodness" on the entry. In one embodiment, a cost-effectiveness metric is applied to the PDS entries. For example, the travel time of different paths can be used as a metric, fuel efficiency can be used as another metric, and the paths can be sorted according to this cost.
[0044] Commutative Action Rule Based Systems (CARBS). CARBS are defined in this paper as RBS where the actions are all commutative. That is, for any two rules Ri and Rj, executing action RAi and then executing RAj is the same as executing action RAj and then executing RAi. This commutativity involves not changing the variables in the row conditions so that the conditions evaluate differently. That is, if Rj previously matched, then executing action RAi will not make the condition of Rj false, and vice versa.
[0045] With CARBS, actions can be performed in any order, so there is no need to Figure 2 The conventional "conflict resolution" process (204) of the normal rule-based system is irrelevant, as is the whole question of conflict resolution strategies. It is therefore possible to execute multiple actions in a processing round without having to rematch after each action is executed, unlike a system based on general conditional action rules, because no action changes a condition that was matched to false or changes a false condition to true. It is also possible to execute rules while exercising appropriate concurrency control over shared data.
[0046] Figure 4 is a flow chart illustrating an embodiment of a process for CARBS execution. In one embodiment, the processing rounds for CARBS are simplified as: matching (402); and / or action (404); Figure 4Because the actions in a processing round do not affect the conditions of another rule, matching and actions can be easily performed in parallel, and conflict resolution (204) is not required. Figure 4 The optimized CARBS can be compared Figure 2 The general rule-based system is substantially more efficient, as well as substantially simpler in implementation and behavior.
[0047] In one embodiment, by limiting the actions during filtering to those that are exchangeable, Figure 3 CARBS is used in the filtering phase (304) of . In one embodiment of filtering (304) using CARBS, the action is restricted to deletion from the PDS. This optimization recognizes that deletion-only filtering requires only commutative actions, as required by CARBS. That is, for example, by making deletion idempotent, deletion of an entry in the PDS is commutative with any other deletion or uniform deletion of the same entry.
[0048] Automated Root Cause Analysis (ARCA). Systems may have many sources of failure, ranging from equipment failure to computer hardware failure to software failure to operator error. In complex systems, there are many dependencies between interconnected components. The mechanisms used to monitor the system may also be subject to failure. Due to dependencies, the failure of one component may cause another component to indicate a fault condition and / or symptom. Cascading failures may result in a large number of alarms, making the task of determining the root cause failure quite difficult. As mentioned in this article, these additional alarms are the "symptoms" of the root cause failure.
[0049] Traditional approaches for automated root cause analysis have attempted to find the root cause by looking for statistical correlations between failures, assuming that strongly correlated failures are the root cause. However, correlation may not indicate causation. Another related statistical approach is to use machine learning techniques to "recognize" different failure scenarios. However, this approach has low reliability unless a very large batch of labeled training sets is available, which may be expensive and / or impractical.
[0050] Automated root cause analysis (ARCA) using ternary failure scenarios is an alternative technique. A "symptom" in this article refers to a specified and / or defined state of a component of a monitored system that is important for distinguishing one failure scenario from another. A "ternary system" as referred to herein can be used for ARCA in part by using symptom values corresponding to "unknown" values (which correspond to unknown symptom values) and "don't care" values (which are also referred to as irrelevant values corresponding to symptoms that are not needed for a particular analysis). In one embodiment, each symptom value is constrained to be one of the following: true, false, or unknown. Therefore, symptom values are referred to as "ternary" values in this article. In one embodiment, the unknown and irrelevant values are specified by the same value, which is distinguished as one or the other based on the context of use.
[0051] CARBS and ARCA. Figure 5A is a flow chart illustrating an embodiment of a process for a decision processing sequence based on ARCA. In one embodiment, Figure 5A The sequence is Figure 3 An ARCA-based version of, for example, makes CARBS an ARCA module, where CARBS is configured and deployed to find faults using entries in a decision set. After generating a potential decision set (502), ARCA can be used as a CARBS, where each row in the root cause table (RCT) is actually a condition associated with a rule, and the action is simply to report a match, which corresponds to the root cause fault to be detected, and this report is exchangeable. Continuing with the above example, the root cause fault of the first driving plan can be identified as "dangerous situation with a stopped vehicle". The rules are used to identify the root cause fault of the ARCA system by utilizing each potential decision to identify the fault (504). For example, the rule: Navigation without entering a dangerous situation with another vehicle is converted to the root cause fault "dangerous situation with another vehicle". After the entry has a detected fault, it is deleted (506) and the "best" entry is selected from the remaining PDS entries (508).
[0052] In some cases, it is useful to convert rules into multiple root cause faults to provide additional information in the PDS about the problem with that entry. For example, in a navigation application, the system may be able to determine the type of many obstacles and some aspects of their behavior. Thus, it may identify an obstacle as a vehicle rather than a road obstacle, and it may identify an obstacle as stopped rather than slow moving.
[0053] Thus, a general rule such as: Navigate without entering a hazardous situation with an obstacle may translate into a batch of root cause failures such as: hazardous situation with unknown obstacle; hazardous situation with slow moving vehicle; hazardous situation with stopped vehicle; hazardous situation with pedestrian; and potentially several more root cause failures. Additionally, the type of obstacle can be used to qualify the nature of the hazardous situation. For example, a hazardous situation with pedestrians can be determined based on parameters specific to pedestrians as opposed to cars.
[0054] The additional information provided in the PDS about the problem with the entry can be used to generate additional navigation plans or how to further improve the PDS. For example, if the root cause problem with the navigation plan to turn right into the rightmost lane has the problem of "dangerous situation with pedestrians", then choosing the alternative of turning into the middle lane is not advisable even if the collision can be avoided. Similarly if the dangerous situation is with an unknown obstacle.
[0055] On the other hand, in some cases, it is desirable to keep the RCT as small as possible to minimize the matching cost to allow it to be suitable for mobile and / or hardware devices (such as ternary CAMs). For these cases, an alternative strategy is to use additional refinements of the rules to avoid false positives and provide information that is not readily available from the identified root cause. In this case, the object specified in the root cause can be determined to be a pedestrian after matching, rather than providing this distinction in the RCT, thereby avoiding the resulting increase in rows.
[0056] In one embodiment, the identification of each root cause is structured so that the root cause can be easily analyzed to determine the general problem and associated parameters. In the example above, the general problem is a hazardous condition, and the parameters are "vehicle" and "stopped".
[0057] In one embodiment, the ARCA module supports multiple matches for a given input (504). The decision process can be informed of all issues with a given PDS entry, thereby enabling a more efficient response. Due to the CARBS constraints, there is no problem in handling multiple matches generated as a result of a single matching process.
[0058] Ternary Matching and ARCA. In one embodiment, CARBS condition matching is implemented using a ternary system for ARCA. As described above, complex monitored systems may have many sources of failure, and even the mechanisms used to monitor such systems are subject to failure. For example, a temperature sensor monitoring a refrigeration system may fail permanently or intermittently, indicating an incorrect temperature of the system being monitored.
[0059] Component dependencies may introduce further complexity, for example, the cooling coils in a refrigeration system depend on the correct operation of the compressor to provide condensed refrigerant. These dependencies arise from the interconnection of these components. As described above, a failure in one component may cause another component to indicate a fault condition / symptom. Therefore, when one component has a failure, it may cause cascading failures in components that are dependent on the failed component, making the task of determining the actual root cause of the failure difficult. In some cases, the root cause may not even be present in the alert provided to the operator.
[0060] For example, if a cable between two computer network switches fails, there may be a large number of alarms from the switches at either end of the cable. However, there are usually no alarms that directly indicate that the cable is broken because there are no sensors on the cable that can directly detect the cable break. Complex systems can also be implemented in multiple layers, creating another set of dependencies. These layer dependencies are another source of alarms. For example, the above cable failure may cause the transport layer to indicate that it has a session timeout because no acknowledgment was received. Similarly, a misconfiguration at the IP layer may cause alarms to be generated at the TCP / transport layer and the routing layer.
[0061] Traditionally, these additional alerts are referred to as symptoms of root cause failures. Generating a large number of these symptoms as alerts makes it more difficult to determine the actual root cause. An efficient method of encoding operating principles, correlations and causal relationships, and potential root causes known to an engineering system as a result of its engineering design is an improvement over ARCA, using efficient matching of symptoms without using statistical correlations between failures or impractical / expensive large training data sets. This efficiency reduces storage costs and / or reduces processor power consumption in order to determine root cause analysis. This efficient method allows root cause analysis to be performed automatically and efficiently.
[0062] Symptoms and failure scenarios. Figure 5B is a graphical representation of a fault scenario vector for a symptom. An example of a symptom, noPower, is a symptom indicating that no power is reaching the monitored system. The state of a symptom can be a known value or a special indication that it is unknown and / or don't care. The term "don't care" is often used in digital logic to indicate that the associated item is irrelevant / unneeded. The ability to handle a process that indicates a don't care for a given symptom allows analysis to be performed even when aspects of the system state are not actually known.
[0063] "Fault scenario" in this article refers to a collection of symptom values that indicate known and unknown fault conditions of the monitored system. From the perspective of observed / determined symptoms (there is a problem or there is no problem with the system), the fault scenario logically represents the state and / or potential partial state of the system. It may not indicate the complete state of the system. For example, for a vehicle, the fault scenario may not necessarily indicate the vehicle's position, speed, etc., but only the state of the symptoms, i.e., the aspects required to perform the root cause analysis of the fault.
[0064] like Figure 5B As shown in , in one embodiment, the fault scenario is represented as an array (512) of values, where each entry (514a-m) corresponds to a specified symptom. For example, symptom Sy0 (514a) is the first entry, symptom Syl (514b) is the second entry, and so on. In one embodiment, there may be multiple symptoms associated with the same metric. For example, a temperature sensor may have different symptoms of slightly high, medium high, and very high. In one embodiment, there may be symptoms associated with the same metric based on different derivative levels. For example, a symptom may be associated with a metric with a first-order derivative that is zero for a long time, that is, the metric is a constant, which generally indicates that the input sensor has failed. A symptom may be associated with a first-order derivative that is too high, meaning that it changes too quickly.
[0065] There may be additional symptoms associated with a metric that indicates that the metric is out of range or is not behaving correctly. In this case, for example, the out of range symptom is set together with symptoms that indicate a metric that is too high or too low. This "aggregation" of symptoms may allow failure scenarios to be specified based on "out of range" without having to cover both "too low" and "too high".
[0066] Define a match operator between two failure scenarios s0 and s1 to return true bool isMatching=match(s0,s1); If each symptom entry in s0 is either unrelated or matches the value in the corresponding entry in sl. Note that the match operation is not commutative; match(a,b) may not necessarily be equal to match(b,a).
[0067] Root cause table. Figure 5Cis a diagram of a root cause table (RCT). An RCT is a table where each row is a failure scenario labeled with an associated root cause. In this context, unknown values for symptoms in such a failure scenario are interpreted as irrelevant. For example, for the root cause "bad engine", the symptoms in this row might be: noPower is false, motorNotRunning is true, and all other symptoms are indicated as irrelevant.
[0068] In one embodiment, the RCT contains rows for each fault or event that may be a root cause, where each row indicates the symptoms that must be true for this to be a root cause, those symptoms that must be false, and the rest are set to indicate irrelevant. Note that specifying more symptoms as a specific value than irrelevant beyond the absolute minimum for a given root cause may result in the root cause not being identified or matched because the additional symptoms may not be known or contrary to the symptoms specified for that row. Therefore, it is important to specify the minimum set of known symptoms required to diagnose the system as a specific root cause associated with the row in the table. If a given root cause may have multiple sets of identified symptoms, there are multiple rows in the RCT, such as one row for each set. A given root cause may have multiple corresponding rows because one row corresponds to the minimum set of symptoms, while other rows correspond to the minimum set with additional symptoms that provide greater confidence in the root cause. For example, in the case of a power failure for a switch, the minimum set may only contain the "lossOfPower" symptom from the switch's current sensor, while additional rows may contain that symptom plus the "lossOfSignal" symptom from the directly attached switch to the failed switch.
[0069] In one embodiment, each RCT row is represented in the same manner as a failure scenario. Thus, it may be referred to herein as a "potential failure scenario". Figure 5C As shown in , RCT (522) includes k+1 rows (524a-3041), each row is associated with a specific root cause, where each row has N symptoms. For example, root cause #0 is associated with the first row (524a). The values of the symptoms (204a-m) in each row (524a) are different from the other rows (524b-3041), and each row corresponds to a potential failure scenario for the associated root cause, as indicated by the root causes labeled #0 to #k.
[0070] In contrast to potential failure scenarios, failure scenarios determined from a monitored system are referred to herein as "actual failure scenarios". There may be multiple actual failure scenarios for a monitored system. For a particular subsystem, one actual failure scenario may be a more detailed failure scenario than another actual failure scenario. Another source of multiple actual failure scenarios is uncertainty about the failure. For example, one scenario may have symptoms corresponding to a system temperature being too low, while another scenario may have symptoms indicating that a temperature sensor has failed. In the latter case, it may indicate symptoms related to the temperature sensor as unknown.
[0071] In one embodiment, a ternary symptom value is used so that the symptom is represented as a "known" bit that indicates known or unknown by being true or false, respectively, and a second "value" bit that indicates true or false, which is interpreted as such only if the known bit is set to true. The quaternary nomenclature is referred to herein as [a,b], where a is whether the state is known (0=unknown, l=known), and b is the value associated with the state (0=false, 1=true). Using this convention, the allowed interpretation of [0,1] is that the associated symptom is unknown is true: compare [0,0], which may correspond to unknown, with [0,1], which may be interpreted as unknown is true. Note that unlike [0,0], the [0,1] symptom in an entry in the RCT may match as the input being false or unknown, which corresponds to "don't care" and matches to any value in the corresponding entry in the actual fault vector. Therefore, [0,1] may not necessarily be considered the same as [0,0], and / or is not allowed.
[0072] Figure 5D is a diagram of a 64-bit block representation of known bits and value bits. In one embodiment, a fault scenario is represented as a block of bits divided into a series of "known" bits and a series of value bits. For example, Figure 5D As shown in , the implementation uses 64-bit blocks, where the first 32 bits are the "known" bits and the second 32 bits are the value bits. Figure 5D , if the i-th known bit is 1, then the i-th value bit indicates whether the corresponding symptom is true or false; otherwise, the actual value is unknown and the i-th value bit is meaningless. This embodiment allows the "known" bits in a block to be efficiently determined. It also means that if all symptoms in a block are unknown or irrelevant, then the block does not need to be stored. That is, the absence of explicit storage of a block is interpreted as the block containing only "irrelevant" values.
[0073] Root cause analysis. Figure 5Eis an illustration of a root cause analysis technique. The actual root cause associated with a given actual failure scenario (532) is determined by using a matching engine (534) to match a given actual failure scenario with each row in the RCT (522) and indicate the given actual failure scenario that matches as a possible root cause. That is, if the failure scenario matches a row such that each entry is matched by the match(a, b) operator described above, then the root cause associated with the row is output as a possible root cause (536) associated with the symptom, as shown in FIG. Figure 5E as shown in .
[0074] This matching is essentially a "ternary match", but unlike the ternary matching provided by a Ternary Content Addressable Memory (T-CAM), the input fault scenarios are also ternary. However, the T-CAM can be used as part of an efficient / hardware matching system. There may be multiple simultaneous root cause failures in the monitored system. Therefore, the match may match multiple rows in the RCT, one for each root cause. For example, an engine may fail at the same time as a temperature sensor fails, by indicating a completely unrealistic reading. There may be multiple rows mapped to the same root cause. This handles the situation where the root cause failure may be indicated by different sets of symptoms.
[0075] In one embodiment, a row representation does not explicitly store irrelevant entries. That is, the absence of an explicit specification or representation of the i-th symptom is interpreted as not caring about the i-th symptom. In one embodiment, symptoms are clustered into blocks associated with logical units or components of the monitored system. For example, an embodiment may use the 64-bit blocks of known bits / value bits previously described. Thus, if a component is irrelevant to a particular root cause, the entire block does not need to be stored. Each row may then require a relatively small amount of memory. Typically, most rows are relatively sparse because only a small subset of symptoms are relevant to a particular fault, so only a small portion of the row is actually stored, and the rest is defaulted to being irrelevant.
[0076] The representation of any fault criteria is achieved by using multiple symptoms. For example, one root cause is evidenced by very high temperature, while another root cause is evidenced by high temperature, and another root cause is evidenced by slightly higher temperature. That is, for each of these levels, there may be a symptom entry in each row.
[0077] The key element is to indicate symptoms that are known to be false as symptoms (i.e., no fault is present), as well as symptoms that are known to be true (i.e., a fault is present), while still accounting for the unknown or unrelated. The false case effectively filters out symptoms that are due to another cause, such as the compressor not working, but there is actually no power, which is the root cause. Thus, a subsystem SSi that depends on many other subsystems may need to have all of these other systems known to be working before a fault in the subsystem SSi can be reliably identified as the root cause.
[0078] In CARBS, each element of a join condition is represented as a ternary symptom. Thus, a condition of the form (C0&Cl&..&Ck) where Ci is a sub-condition can be represented as a row where the "symptoms" corresponding to these sub-conditions are set to true. If Ci is actually the negation of some condition C'i, then instead the symptom corresponding to C'i is set to false.
[0079] A condition of the form (A or B) can be converted to two rows, one corresponding to A and the other corresponding to B. A post-processing stage can merge the two matches if desired when both match, or convert to a non-match if exclusive OR semantics are required. Using this approach, each row of the RCT conversion table is treated as representing an attribute of an element, which is actually a condition associated with a rule that needs to be true for that object. The matching algorithm is then modified to report a mismatch instead of a match. In one embodiment, binary symptoms are used instead of ternary symptoms.
[0080] Example Situation: Autonomous Vehicle Driving / Navigation. To illustrate the disclosed technology in a dynamic scenario, the use of the disclosed technology in the field of autonomous vehicle navigation in an environment with other autonomously driven vehicles or human-driven vehicles and other obstacles (where dynamic information about these other vehicles and obstacles is collected from sensors) is a known context.
[0081] In one embodiment, the CARBS module is used with the scalability and efficiency of ARCA, for example, using ternary matching. In one embodiment, the associated RCT is automatically generated and / or "compiled" from the high-level fault model using known techniques. As mentioned herein, compiling a high-level fault model is any technique for automatically generating an RCT from the high-level fault model. For example, an attribute or condition similar to a root cause is specified, and this condition is propagated outward to other elements as a "symptom" as needed to make the condition observable. Therefore, the symptoms in the rows of the RCT conversion table are set to match the conditions of the rule. As described herein, it is direct to convert these conditions to their negation and use the match with the resulting row to correspond to the failure in the selected potential decision. Without limitation, for clarity, the following is described in ARCA terms, using the ARCA module to detect rule matches with entries in the PDS.
[0082] Figure 6 is a flow chart illustrating an embodiment of a process for an ARCA-based autonomous driving processing sequence. In one embodiment, Figure 6 The sequence of is based on ARCA-based decision making on driving plans using the sequence illustrated in FIG5 . Figure 6 Before the process, a series of models are generated a priori for different driving scenarios, such as the fault model "dangerous Situation With Stopped Vehicle Vi". Each model may include elements corresponding to the navigation vehicle and other vehicles and obstacles.
[0083] In (602), a fault model corresponding to the current driving scenario is selected. In (604), an RCT is compiled based at least in part on the selected fault model. In (606), telemetry objects are assigned to model elements, where the telemetry objects can be vehicles, obstacles, pedestrians, etc. In (608), route-specific telemetry is assigned to element inputs, where the route-specific telemetry can include lane positions, road signs, pedestrian crossings, etc. In (610), GFSDP is executed; in one embodiment, this includes the steps of Figure 5. If it is determined in (612) that the current driving scenario selected in the initial (602) has changed, control is transferred back to (602) for the new selection; otherwise, control is transferred back to (610). In an active driving scenario, sensors are read every 100 milliseconds (for example), and these sensors indicate a change in the current driving scenario, so control is transferred back to (602).
[0084] Actual and Potential. In one embodiment, to avoid having the model be specialized for each specific scenario, the model includes a collection of "potential" vehicles and obstacles, as described in (606). A potential vehicle or obstacle then becomes "actual" only when it is paired with telemetry that has detected an actual object in the environment. Until then, it is inactive and therefore does not interact with the navigating vehicle, so it does not actually exist in the environment from the perspective of ARCA, that is, it is not the source of a root cause failure.
[0085] To illustrate, when a vehicle appears in front of another vehicle, the other vehicle may be heading down a residential street with no vehicles in sight, causing the other vehicle to pull out of the driveway. At this point, the telemetry is assigned to one of the potential vehicles in the model and RCT and marked as actual in (606). One way to mark it as actual is to simply set its position relative to the navigated vehicle, rather than setting some very distant position from which all potential vehicles start. In this way, the model and generated RCT do not need to change in the dynamic appearance of the new object, but there is no irrelevant root cause failure identified.
[0086] Time. In one embodiment, to incorporate time into ARCA and RCT, each object is implemented as a batch of elements in the model corresponding to a time series, i.e., an object at time t0, an object at t1, an object at t2, and so on to an object at time tn. Each of these elements has its own copy of the symptoms represented in the RCT. The setting of these symptoms corresponds to an extrapolation of the object forward in time based on the telemetry information. In particular, in the case of a vehicle traveling at a speed v, the extrapolated position of the vehicle at time t is its current position plus v*t, possibly taking into account acceleration and so on. More complex models of other vehicles can be used. For example, if another vehicle is approaching an intersection, its speed can be expected to decrease.
[0087] For a navigating vehicle, its position at time ti corresponds to its planned position according to the proposed navigation plan being evaluated. The meaning of t0 is the current time at which the ARCA module is running, so t0 is the current position of the navigating vehicle. Therefore, the number of entries in the time series may be limited to provide sufficient reaction time while still providing accurate ARCA. For example, driving on a residential street at 25MPH, using a time series of 20 entries, where each entry in the sequence represents an additional second, there is 20 seconds of reaction time, which is sufficient to avoid dangerous situations, but provides a second level of accuracy regarding the location of the vehicle and obstacles. At highway speeds, similar parameters apply, except that one will require a larger distance between vehicles.
[0088] Symptom Propagation. In one embodiment, a navigated vehicle (NV) object at time ti is connected to every other vehicle and obstacle object at time ti. The root cause specific to each vehicle instance in the navigated vehicle is propagated across these connections to the NV to the corresponding obstacles. For example, specify "dangerousSituationWithStoppedVehicleVi" as the symptoms "dangerousSituationWithNv" and "vehicleStopped" to propagate from each connected vehicle Vi. This is referred to as symptom propagation in this article. These are observed symptoms that are set to true if the position of the navigated vehicle would be too close to Vi and then if Vi is stopped. Therefore, if a given connected vehicle Vi is actual as above and its position at time ti is extrapolated to be within a specified distance of the navigated vehicle NV at time ti, the "dangerousSituationWithNv" symptom is set for that vehicle.
[0089] In one embodiment, if the telemetry indicates that the vehicle is stopped, i.e., at zero speed, then the "Stopped" symptom is set for that vehicle. Thus, the model is compiled into an RCT (604) with a row corresponding to "Dangerous situation with stopped vehicle Vi at time ti", and the row is matched when both of these specific symptoms are set. In this way, ARCA may be well positioned to identify a future potentially dangerous situation if the current proposed navigation plan is followed. It may also indicate when this situation will occur.
[0090] For example, if ti is well in the future, the system may choose an alternative plan. However, if ti is almost instantaneous (such as when an obstacle suddenly appears), the system may initiate emergency braking or evasive maneuvers. In particular, such rules illustrate the key benefits of rule-based decision making, where the NV system determines that the NV will emergency brake if it detects an unknown obstacle (with which it may have an immediate collision). Therefore, this basic safety property can be guaranteed. Unlike ML and / or deep learning (DL) methods, systems using the techniques disclosed herein can therefore be guaranteed to act safely when they do not understand the scene.
[0091] Safety perimeter. In one embodiment, to avoid missing detection of hazardous situations caused by objects between time points, the size of the safety perimeter around the object can be expanded at an increasing rate relative to the time step granularity. This is similar to the expanded boundary geometry used in prior art collision detection methods.
[0092] Speed. In addition to basic rules about avoiding hazardous situations such as potential collisions, the model may include rules such as upper and lower limits on speed that are conditioned on its state relative to the rest of the environment. For example, a navigating vehicle may have a rule to travel at least 55MPH on a highway if the speed limit is 65, road conditions are good, and there are no immediate obstacles or hazardous situations.
[0093] Navigation scenario models. In one embodiment, to avoid having too large an RCT and the associated matching overhead, there may be a model for each of the navigation scenarios: crossing a residential street; approaching a stop sign; turning right at a 4-way stop; etc. For example, a residential driving rule set may have a rule that prohibits maintaining or increasing speed if a ball is rolling in front of the vehicle, while a highway driving rule set may not mention balls, but prohibits staying in the same lane if there is an available left adjacent lane and there is a stopped vehicle in the right adjacent lane, which is on the other hand allowed in residential driving. Then, as the driving scenario changes, the system can switch to using the associated RCT. For example, it may have a current RCT corresponding to crossing a residential street, and then switch to using the RCT corresponding to "approaching a stop sign" as it approaches the end of the street. The system may have a whole batch of RCTs available for selection at any time, or if not already stored in (604), the RCTs may be compiled from the model just before they are needed.
[0094] In this example application of autonomous vehicle driving / navigation, it is reasonable to feed less than 30 objects (606), each driving scenario has a relatively equal number of general root causes, about 10 time steps are required, and the resulting model and RCT may end up with about 9,000 rows. This is reasonable to handle effective root cause analysis, especially with an effective ARCA implementation. Using the above techniques, RCT matching can be performed in parallel and / or in hardware for faster response.
[0095] In one embodiment, in (610), ARCA is performed on a set of potential navigation plans in order from "best" to worst, using a metric such as cost, and terminates when a plan without a fault is identified. However, by having an ARCA for each logical object, each time step, and each plan, the model can be extended to handle multiple plans simultaneously. For example, it might include a normal plan as well as several evasive maneuver plans so that in the event of an impending collision, it is able to react to one or two options to quickly respond to the dangerous situation. The impending collision fault condition only needs to propagate to the next few time steps, so fewer RCT lines are introduced at compile time (604). In the same way, having the eventualCollision only propagate to later time steps means that the combination of the two does not increase the number of RCT lines.
[0096] Note that model complexity is handled when compiling the model (604). The size of the generated RCT incurs a real-time cost, namely the cost of matching actual symptoms to RCT rows, and the space cost of the RCT itself.
[0097] Other improvements. Various other improvements are available. In one embodiment, hardware support such as T-CAM can be used to perform more efficient matching. In this case, when a new driving scenario is selected at (602), the RCT is loaded into the T-CAM, and then for each decision round, a matching vector is input into the T-CAM for each entry of the PDS. In this case, since the T-CAM may process many matches per millisecond, it is preferable to make the model correspond to a single time point rather than a time series to thereby reduce the size of the RCT. Then, if the plan provides 20 waypoints for its trajectory, a matching vector will be generated for each waypoint and matched using the T-CAM. If each match takes 50 microseconds, it takes 1 millisecond to evaluate 20 waypoints. Therefore, even if the first four plans are eliminated, five different driving plans can be evaluated in 5 milliseconds. Therefore, it becomes feasible to reevaluate the driving plan every 100 milliseconds, and if necessary, it may be reevaluated more frequently.
[0098] In one embodiment, another optimization is dynamic model generation of the RCT, which drives off databases of different meta-scenarios such as intersections, freeway exits, on-ramps, etc. For example, consider a four-way stop where the NV is turning left. A model more specific to the current scenario can be generated as needed, resulting in a smaller RCT and improved efficiency in matching for the current scenario.
[0099] A variation of this application is to use the RSS model to assign liability if the navigated vehicle is involved in an accident. With RSS, it is impossible to guarantee that an accident will not occur. However, if the navigated vehicle fails to take appropriate action in the event of a hazardous situation, it is at fault. Similarly, and not less expected, if another vehicle fails to take appropriate action in the event of a hazardous situation as defined by the rules in RSS, or creates a hazardous situation that leads to an accident, it is at fault. Liability determination can be determined by applying ARCA based on the same telemetry (including historical telemetry) to determine the root cause of the accident, which is yet another decision.
[0100] This application shows the benefits. By performing ACRA on a PDS that is separate from PDS generation, it avoids complicating the already complex task of generating potential navigation paths. Assuming that any unsafe driving plans are filtered out by the ARCA rules, assuming that these rules correctly reflect safe behaviors (such as those specified in the RSS), it also provides a simple guarantee that the NV is prevented from performing unsafe actions. It also means that rule-based filtering can use optimizations that can be used for CARBS systems, where ARCA can be considered an instance of a CARBS system. By using the recently developed efficient ARCA RCT representation and matching and the methods and optimizations described in this article, rule evaluation can be performed relatively efficiently and therefore frequently, allowing the NV to react quickly to changing situations.
[0101] Note that, except for off-road driving, the preferred driving plan generated by the current on-road navigation program is acceptable most of the time with minor changes and improvements, such as when to change lanes and the exact orientation on the road. That is, other vehicles and obstacles rarely cause problems with the conventional plan. Therefore, the NV can be expected to drive as expected most of the time. On the other hand, in certain confusing or unexpected situations, slowing down or stopping is guaranteed, thereby ensuring safe operation - in sharp contrast to the lack of such guarantees with traditional statistical methods. In off-road situations, automated driving may depend more on the environment.
[0102] Sensor interpretation verification. Another application area for incorporating rules into complex automated decision making is verifying sensor interpretations or data inputs. As a specific application of this type of verifying sensor interpretations, autonomous vehicles have sensors to detect not only the presence of potential obstacles, but also what the obstacle is, its speed, and possibly its acceleration.
[0103] High accuracy has traditionally been difficult to achieve due to uncertainty from camera images, deformations caused by rain and sunlight, and difficulties in interpreting images. In addition, traditional methods based on statistical inference / machine learning are based on training sets. Encountering sensor inputs that deviate from the training set increases the uncertainty that the generated interpretation is correct and therefore reduces reliability. Furthermore, carrying this uncertainty into navigation using traditional methods significantly complicates navigation and also tends to make driving too conservative and / or slow compared to human drivers.
[0104] Applying the techniques discussed herein, rules are applied to verify that candidate identifications of an object and its attributes conform to the rules associated with that object type. In one embodiment, if the rules eliminate all candidate interpretations, the image and scene are identified as unknown / uncertain, and this determination can be used to prompt more conservative driving or possibly pausing the vehicle, thereby increasing the safety of NV operation.
[0105] Figure 7 is a flow diagram illustrating an embodiment of a process for an ARCA-based sensor interpretation processing sequence. In (702), conventional techniques including machine learning are used to generate a set of hypotheses representing potential interpretations of sensor inputs. For each object of this type, there is a set of rules that such objects obey. For example, in the case of a bicycle, the rule may be that its speed is greater than zero but less than 25MPH. Based on these rules, an individual can identify a set of root causes for the object not complying with these rules. For example, in the case of a bicycle, the root cause may be "excessivelyFast", which propagates to the distance between time series associated with bicycles being too far apart. Another example may be an "excessivelyWide" root cause, which propagates to the width of the object as determined in an image that is too large.
[0106] Thus, in (702), sensor data processing produces a set of potential image / sensor interpretations, optionally sorted by confidence. In (704), for a given interpretation in the set generated in (702), a fault model for the object type is selected. In (706), the given interpretation is examined for causes of faults with the interpretation using ARCA on sensor input telemetry. In (708), if the given interpretation exhibits a fault, it can be eliminated. In (710), if the unprocessed interpretation is retained, control is transferred to (704), otherwise control is transferred to (712), where the interpretation with the highest confidence among the remaining interpretations in the set is selected.
[0107] In some cases, telemetry data alone is used as part of the filtering. For example, a camera and image processing can be used to detect that an object "looks like" a bicycle, where as a rangefinder can be used to determine its speed.
[0108] An improvement of the optimized CARBS method is that these rules can be applied quickly and efficiently, so the image interpretation process is not significantly delayed by the addition of a filtering step. In addition, it is feasible to have a model that contains one instance of each potential interpretation, and assign "symptoms" from various metrics to each of these instances, where then the ARCA match in a single match can be indicated with each possible interpretation.
[0109] For example, if the object possibilities are: motor vehicle, bicycle, pedestrian, and road obstacle, the model may include instances of each object and the root cause problems with each type of object, so ARCA matching may detect a "failure" with the object interpreted in parallel as each of these objects (if any). If it does not detect a problem with any interpretation, the selection will typically use the most likely interpretation and / or the least dangerous interpretation.
[0110] Fusion of multiple images. Another related application area for incorporating rules into complex automated decision making is the fusion of multiple sensor / data input interpretations, such as fusing multiple images. In applications such as image interpretation (particularly medical image interpretation), there may be multiple images of the same part of the body, such as an image of a kidney with a suspected tumor. A variety of different potential interpretations may be generated from each image. In this case, the images correspond to different views generated from different angles but at the same time, in contrast to different views generated from different times (as occurs in the case of vehicle navigation).
[0111] Applying the techniques described in this paper, the objects corresponding to a feature at each view are analyzed. Rules are used to generate root cause failures to identify problems with each image interpretation (if any). Differently viewed objects are connected by matching features in different images to common elements, allowing symptom propagation and domain knowledge to be applied to specify how symptoms propagate within the model.
[0112] Figure 8 is a flow chart illustrating an embodiment of a process for an ARCA-based sensor fusion processing sequence. In (802), conventional techniques including machine learning are used to generate a set of hypotheses representing potential explanations for multiple sensor and / or multiple image views. For example, if a growth is potentially identified on a top view of a kidney, then a side view should also indicate a growth at the same location.
[0113] In (804), for a given interpretation in the set generated in (702), a fault model of the object type is selected. In (806), features are associated between the images / sensor inputs as elements, and in (808), the given interpretation is examined for causes of faults with the interpretation using ARCA for sensor input telemetry. Thus, a model specified for kidney tumor diagnosis will result in a fault of the given interpretation of the set with kidney images at all if a growth is identified in one view but not in another view where it should be visible. As an improvement, (802) may generate a PDS that includes both "small growths" as well as "large growths". The ARCA in (808) may find faults with large growth entries, but not with small growth entries, thereby improving the decision to output small growths.
[0114] At (810), if a given interpretation exhibits a fault, it may be eliminated. At (812), if an unprocessed interpretation is retained, control is transferred to (804), otherwise control is transferred to (814), where the interpretation with the highest confidence among the remaining interpretations in the set is selected.
[0115] More generally, in the case of medical applications, the image may be only part of the input used to perform a diagnosis. For example, the patient's temperature, blood pressure, and heart rate may also be measured. In this case, the image processing output can be considered to essentially set the symptoms, and it is the ARCA that provides the actual output, that is, the root cause of the failure is the diagnosis.
[0116] In one embodiment, the image can be interpreted using Figure 8 The invention also provides a technique for improving candidate image interpretations with this additional telemetry as input. For example, a high heart rate may be a negative indicator for a certain interpretation of a cardiac image.
[0117] Rationale. The approach of partitioning decision making into three phases: generation, filtering, and selection significantly reduces the complexity of the generation phase when using rules. For example, without this partitioning, if a rule is valid (A and B) or (not A and C) if condition C is only determined at the end of the generation, the generation needs to remember the A condition, but not determine whether the rule is followed until C is determined. Therefore, in the worst case, the non-partitioned decision still ends up being able to do a full rule evaluation only after the generation is completed.
[0118] The separate stages of the techniques described herein also make it feasible to use independent and distinct means to generate potential decisions. For example, a rule-based system is not typically used to match images. Instead, statistical / ML approaches are favored. With this separation, statistical methods can generate a set of explanations, which can then be filtered based on rules using ARCA. Strategically, it may be difficult to otherwise mix these two approaches in a single decision step.
[0119] Using a separate rule-based system to do only filtering significantly simplifies the rule-based system since its actions as a filtering mechanism are interchangeable, thereby allowing the use of CARBS as described herein.
[0120] Detection using ARCA implementations (such as using ternary matching) to perform rule matching is a further improvement by separating the setting of symptoms from the matching, so that the setting of symptoms can be adjusted based on the properties of the obstacle. For example, if an obstacle is far away from the navigating vehicle, its symptoms can only be updated by appropriate calculations over a longer period of time (rather than a closer period of time), and filtering actions need to be performed at regular short intervals (such as every 100 milliseconds) to detect dangerous situations caused by nearby obstacles. In addition, the setting of symptoms can be performed in parallel by separate processes or threads. Similarly, the simple ternary representation of RCT allows for hardware implementations of matching (such as ternary CAM), which greatly improves the efficiency of matching.
[0121] Fig. 9 is a flow chart illustrating an embodiment of a process for incorporating rules into complex automated decision making. In one embodiment, Fig. 9 The process of Figure 1 system execution.
[0122] In (902), a set of input conditions is obtained. In one embodiment, the input conditions are determined based at least in part on telemetry. In one embodiment, the telemetry includes measurements, characteristics, and / or properties associated with a physical object.
[0123] At (904), a plurality of potential decisions are obtained based at least in part on the set of input conditions. In one embodiment, obtaining the plurality of potential decisions includes generating and / or receiving the potential decisions. In one embodiment, the potential decisions determine potential actions to be taken relative to the current state. In one embodiment, the potential actions, when executed, change the current state and / or the potential decisions.
[0124] At (906), the rule-based system is used to process the plurality of potential decisions and obtain a set of one or more updated potential decisions. In one embodiment, processing the plurality of potential decisions using the rule-based system includes filtering the plurality of potential decisions using the rule-based system.
[0125] In one embodiment, a rule-based system allows for processing multiple potential decisions to perform multiple corresponding actions on selected potential decisions. For example, CARBS is an example of such a rule-based system. In one embodiment, the multiple corresponding actions can be performed in different orders without affecting the rule conditions of the multiple rules.
[0126] In one embodiment, the rule-based system is configured to perform automated root cause analysis, wherein a root cause failure corresponds to a failure related to a potential decision, and the root cause failure is mapped to a rule action. In one embodiment, the rule action includes one or more of: deleting, re-ranking by importance, re-evaluating, and / or modifying one or more potential decisions that match at least one rule in the rule-based system.
[0127] In one embodiment, a rule-based system specifies a plurality of rules. In one embodiment, the rules specify rule conditions and corresponding actions, wherein when the rule conditions are satisfied, the corresponding actions are performed. In one embodiment, processing of the plurality of potential decisions includes: 1) for a selected potential decision from the plurality of potential decisions, determining whether the rule conditions are satisfied for a selected rule from the plurality of rules, wherein the selected rule conditions are at least partially dependent on the selected potential decision; and 2) in response to the selected rule conditions being satisfied, performing the corresponding action.
[0128] In one embodiment, such action affects a potential decision that is selected. In one embodiment, executing the rule action includes deleting one of the one or more potential decisions identified. In one embodiment, determining whether the rule condition is satisfied is based at least in part on a ternary match. In one embodiment, executing the rule action is performed in parallel.
[0129] In one embodiment, the selected rule condition also depends at least in part on the set of input conditions. In one embodiment, the best updated decision is selected from a set of one or more updated decisions based at least in part on a benefit metric (e.g., a metric associated with safety, time, quality, efficiency, and / or cost).
[0130] At (908), a set of one or more updated potential decisions to be executed is output. In one embodiment, the plurality of potential decisions include potential navigation decisions for the vehicle. In one embodiment, the potential decisions are applied to autonomous driving. In one embodiment, the potential navigation decisions include at least one of: merging, accelerating, decelerating, and turning. In one embodiment, the plurality of rules at least partially include hazardous situations, such as hazardous situations as defined in a responsibility-sensitive safety (RSS) framework.
[0131] In one embodiment, the plurality of potential decisions comprise interpretations of visual images. In one embodiment, the plurality of potential decisions comprise interpretations of fused images of the same object or scene.
[0132] Simple Example. Table 1 below gives a simple example of a root cause table using the disclosed technology: Table 1. Simple example of a root cause table As shown in Table 1, if (Cl&C5&C6'), which means there is a person in front of the NV, the NV keeps going straight, and the NV does not turn right, then these sub-conditions match the root cause "dangerous situation with pedestrians". Similarly, if (C1'&C2&C6), or there is no person in front of the NV, there is a person on the right side of the NV, and the NV turns right, then these sub-conditions also match the root cause "dangerous situation with pedestrians".
[0133] As shown in Table 1, if (C3&C5&C6'), which means there is another car in front of the NV, the NV keeps going straight, and the NV does not turn right, then these sub-conditions match the root cause "dangerous situation with a vehicle". Similarly, if (C4&C5'&C6), or there is a vehicle on the right side of the NV, the NV does not go straight, and the NV turns right, then these sub-conditions also match the root cause "dangerous situation with a vehicle".
[0134] The two rules in CARBS associated with simple RCT in Table 1 include: Condition {if (PDS & input condition) results in a dangerous situation with pedestrians} -> Action {against}; and Condition {if (PDS & input condition) results in a dangerous situation with the vehicle} -> action {against}.
[0135] Although the foregoing embodiments have been described in some detail for purposes of clarity of understanding, the invention is not limited to the details provided. There are many alternative ways of implementing the invention. The disclosed embodiments are illustrative and not restrictive.
Claims
1. A system comprising: processor; as well as a memory coupled to the processor, wherein the memory is configured to provide instructions to the processor that, when executed, cause the processor to: Get a set of input conditions; obtaining a plurality of potential decisions based at least in part on the set of input conditions; The plurality of potential decisions are processed using a rule-based system and a set of one or more updated potential decisions is obtained, wherein: The rule-based system specifies a plurality of rules; A rule specifies a rule condition and a corresponding action, wherein when the rule condition is met, the corresponding action is to be performed; and The processing of the plurality of potential decisions includes: for a selected potential decision from the plurality of potential decisions, determining for a selected rule from the plurality of rules whether the rule condition is satisfied, wherein the selected rule condition depends at least in part on the selected potential decision; and In response to satisfying the selected rule condition, performing the corresponding action; and A set of the one or more updated potential decisions to be executed is output.
2. The system of claim 1, wherein obtaining a plurality of potential decisions comprises generating and / or receiving potential decisions.
3. The system of claim 1, wherein potential decisions determine potential actions to be taken relative to a current state.
4. The system of claim 3, wherein the potential action, when executed, changes the current state and / or potential decision.
5. The system of claim 1, wherein using the rule-based system to process the plurality of potential decisions comprises using the rule-based system to filter the plurality of potential decisions.
6. The system of claim 1, wherein the rule-based system enables processing of the plurality of potential decisions to perform a plurality of corresponding actions on the selected potential decision.
7. The system of claim 6, wherein the plurality of corresponding actions can be performed in a different order without affecting the rule conditions of the plurality of rules.
8. The system of claim 1, wherein the selected rule condition also depends at least in part on the set of input conditions.
9. The system of claim 1, wherein the input condition is determined at least in part based on telemetry.
10. The system of claim 1, wherein the rule-based system is configured to perform automatic root cause analysis, wherein a root cause failure corresponds to a failure related to an underlying decision, and the root cause failure is mapped to a rule action.
11. The system of claim 1, wherein the rule action comprises one or more of: deleting, re-ranking by importance, re-evaluating, and / or modifying the one or more potential decisions matched to at least one rule in the rule-based system.
12. The system of claim 1, wherein the plurality of potential decisions include potential navigation decisions for a vehicle.
13. The system of claim 12, wherein potential navigation decisions include at least one of: merging, accelerating, decelerating, and turning.
14. The system of claim 1, wherein the plurality of potential decisions comprises interpretations of visual images.
15. The system of claim 1, wherein the plurality of potential decisions comprise interpretations of fused images of the same object or scene.
16. The system of claim 1, wherein performing the rule action comprises deleting one of the identified one or more potential decisions.
17. The system of claim 16, the processor further configured to select a best updated decision from the set of one or more updated decisions based at least in part on a dominance metric.
18. The system of claim 17, wherein the potential decision is applied to autonomous driving.
19. The system of claim 18, wherein the plurality of rules comprises, at least in part, hazardous situations.
20. The system of claim 19, wherein the hazardous situation is defined in a Responsibility Sensitive Safety (RSS) framework.
21. The system of claim 1, wherein determining whether the rule condition is satisfied is based at least in part on a ternary match.
22. The system of claim 1, wherein executing rule actions is performed in parallel.
23. A method comprising: Get a set of input conditions; obtaining a plurality of potential decisions based at least in part on the set of input conditions; The plurality of potential decisions are processed using a rule-based system and a set of one or more updated potential decisions is obtained, wherein: The rule-based system specifies a plurality of rules; A rule specifies a rule condition and a corresponding action, wherein when the rule condition is met, the corresponding action is to be performed; and Processing the plurality of potential decisions using the rule-based system includes: for a selected potential decision from the plurality of potential decisions, determining for a selected rule from the plurality of rules whether the rule condition is satisfied, wherein the selected rule condition depends at least in part on the selected potential decision; and In response to satisfying the selected rule condition, performing the corresponding action; and A set of the one or more updated potential decisions to be executed is output.
24. A computer program product embodied in a non-transitory computer-readable storage medium and comprising computer instructions for: Get a set of input conditions; obtaining a plurality of potential decisions based at least in part on the set of input conditions; The plurality of potential decisions are processed using a rule-based system and a set of one or more updated potential decisions is obtained, wherein: The rule-based system specifies a plurality of rules; A rule specifies a rule condition and a corresponding action, wherein when the rule condition is met, the corresponding action is performed; as well as Processing the plurality of potential decisions using the rule-based system includes: for a selected potential decision from among the plurality of potential decisions, determining for a selected rule from among the plurality of rules whether the rule condition is satisfied, wherein the selected rule condition depends at least in part on the selected potential decision; as well as In response to satisfying the selected rule condition, performing the corresponding action; and A set of the one or more updated potential decisions to be executed is output.
