Behavior tree-based autonomous driving test method, device, storage medium, and equipment

Abstract

The present invention discloses a behavior tree-based autonomous driving test method, apparatus, storage medium, and equipment, relating to the field of autonomous driving. The method comprises: obtaining a test map, constructing a test scenario based on the test map and selecting a dynamic target, obtaining an atomic action set of the dynamic target and the behavior trajectory of the dynamic target in each test sub-scenario included in the test scenario; based on the atomic action set, decomposing the behavior trajectory into at least one atomic action, and determining the temporal logic relationship of the atomic actions; combining the temporal logic relationship in each of the test sub-scenario, and creating a behavior tree corresponding to the test scenario based on the combination result; running the behavior tree to obtain the autonomous driving test results of the object under test. The present invention realizes autonomous driving testing in non-solidified and more diverse test scenarios.

Description

Technical Field

[0001] The present invention relates to the field of autonomous driving, and in particular to a behavior tree-based autonomous driving testing method, apparatus, storage medium, and equipment. Background Art

[0002] In recent years, the safety of autonomous driving has received widespread attention due to the increasing number of news reports of casualties caused by intelligent unmanned systems.

[0003] The international standard ISO 21448 SOTIF (Safety of the Intended Functionality) points out that it is necessary to generate many scenarios in the initial development stage of safety testing to identify all possible situations. Therefore, building a diverse and massive test scenario is a core issue in autonomous driving test research. In autonomous driving testing, there are generally two methods to generate test scenarios, namely real road testing and simulator-based simulation testing. Real road testing is costly and inefficient, while simulator-based simulation testing can solve these problems and generate virtual test scenarios. There are many autonomous driving simulation test platforms in related technologies, such as Carla, AirSim, Lgsvl, Apollo, etc.

[0004] However, the test scenarios used in the autonomous driving simulation test platform in the related art are fixedly generated, and the test scenarios are single and not rich and diverse enough. Summary of the Invention

[0005] To address the problem that test scenarios are fixedly generated and lack richness and diversity, the present invention provides an autonomous driving test method, device, storage medium and equipment based on behavior trees.

[0006] The technical solution of the present invention includes:

[0007] A behavior tree-based autonomous driving testing method, characterized in that the method includes:

[0008] Acquire a test map, construct a test scenario based on the test map and select a dynamic target, obtain an atomic action set of the dynamic target and a behavior trajectory of the dynamic target in each test sub-scenario included in the test scenario, wherein the dynamic target includes a tested object and a dynamic element;

[0009] Based on the atomic action set, decomposing the behavior trajectory into at least one atomic action, and determining the temporal logical relationship of the atomic actions;

[0010] Combining the temporal logic relationship in each of the test sub-scenarios, and creating a behavior tree corresponding to the test scenario based on the combination result;

[0011] The behavior tree is run to obtain an autonomous driving test result of the tested object.

[0012] Optionally, the temporal logic relationship includes at least one of: atomic action serialization, atomic action parallelization, and atomic action repetition.

[0013] Optionally, combining the temporal logic relationship in each of the test sub-scenarios includes:

[0014] combining the same dynamic target in each of the test sub-scenarios;

[0015] The temporal logic relationship of the atomic actions of different dynamic targets in each of the test sub-scenarios is combined to obtain the combination result.

[0016] Optionally, creating a behavior tree corresponding to the test scenario includes:

[0017] Based on the temporal logic relationship, marking the behavior directed identifiers between the atomic actions, and generating a behavior directed graph according to the behavior directed identifiers;

[0018] Constructing an adjacency matrix of the behavior directed graph by determining whether each of the atomic actions in the behavior directed graph has a successor node;

[0019] Create a behavior tree corresponding to the test scenario based on the adjacency matrix and behavior tree creation conditions, where the behavior tree creation conditions include:

[0020] Add a sequential parent node before each of the atomic actions;

[0021] If an atomic action has only one successor node, the successor node is used as a child node of the sequential parent node of the atomic action;

[0022] If an atomic action has multiple successor nodes, each successor node is used as a child node of a parallel parent node, and the parallel parent node is used as a child node of the sequential parent node of the atomic action;

[0023] If an atomic action has multiple predecessor nodes, the states of all the predecessor nodes are used as a trigger event, the trigger event is used as a new predecessor node of the atomic action, the new predecessor node is used as a child node of the root node, and the new predecessor node, the atomic action, and the successor node of the atomic action are formed into a new subtree;

[0024] If an atomic action has no predecessor node, the atomic action is used as a child node of a parallel node, and the parallel node is used as the root node of the behavior tree.

[0025] Optionally, running the behavior tree includes:

[0026] Create and initialize a behavior subtree, and start a timer and listener for the behavior subtree. The timer is used to record the running time of the behavior tree, and the listener is used to monitor abnormal situations that occur during the running of the behavior tree.

[0027] The pre-order traversal is performed on each node of the behavior tree, the node corresponding to the atomic action is executed, and it is determined whether the execution behavior of the node satisfies the completion condition of the atomic action corresponding to the node, so as to obtain the execution status of the node.

[0028] Optionally, running the behavior tree further includes:

[0029] Establishing a decision subtree, wherein the decision subtree is used to determine and evaluate the running result of the behavior tree;

[0030] When all nodes of the behavior tree are traversed, the decision subtree is executed.

[0031] Optionally, the method further includes:

[0032] Based on any two adjacent test sub-scenarios and the behavior trajectory of the dynamic target in the test sub-scenarios, a transition scene and the behavior trajectory of the dynamic target in the transition scene are constructed; wherein the test scene includes the test sub-scenarios and the transition scene.

[0033] An autonomous driving test device based on a behavior tree, comprising:

[0034] A setting module is configured to obtain a test map, construct a test scenario based on the test map, select a dynamic target, and obtain an atomic action set of the dynamic target and a behavior trajectory of the dynamic target in each test sub-scenario included in the test scenario, wherein the dynamic target includes a tested object and a dynamic element;

[0035] A generating module, configured to decompose the behavior trajectory into at least one atomic action based on the set of atomic actions, and determine a temporal logical relationship of the atomic actions;

[0036] A creation module, configured to combine the temporal logic relationships in each of the test sub-scenarios and create a behavior tree corresponding to the test scenario based on the combination results;

[0037] The running module is used to run the behavior tree to obtain the autonomous driving test result of the tested object.

[0038] A computer device includes a memory and a processor, wherein the memory stores a computer program, and the processor loads and executes the computer program to implement the above-mentioned behavior tree-based autonomous driving testing method.

[0039] A computer-readable storage medium stores a computer program, which, when executed by a processor, implements the above-mentioned behavior tree-based autonomous driving testing method.

[0040] A computer program product, when running on a computer device, causes the computer device to execute the above-mentioned behavior tree-based autonomous driving testing method.

[0041] Compared with the prior art, the present invention has the following advantages:

[0042] 1. For autonomous driving simulation testing applications, a behavior tree-based solution for controlling the behavior of the tested object and dynamic elements is provided. During the behavior tree generation process, a large number of rich and diverse dynamic test scenarios can be generated through the serial and parallel combination of atomic actions of the tested object and dynamic elements.

[0043] 2. The description of temporal logic relationships is introduced into the combination of atomic actions. The atomic actions of the measured objects and dynamic elements are combined in time and space. This provides a new perspective for describing the temporal and spatial aspects of different individual behaviors based on temporal logic relationships. The behavior description is clearer and more concise, and it is easier to reflect the behavioral interactions between different subjects.

[0044] 3. Dynamic elements appear dynamically in the test sub-scenes, making it easy to flexibly adjust the number of dynamic elements in different test sub-scenes and flexibly add or delete dynamic elements;

[0045] 4. By combining multiple test sub-scenarios into a test scenario, you can flexibly combine and build test scenarios to suit different test tasks;

[0046] 5. Appropriately adding transition scenarios between different test sub-scenarios can smooth the switching between different test sub-scenarios, make it more in line with actual testing, and ensure the consistency of the operation of the tested object in different test sub-scenarios. BRIEF DESCRIPTION OF THE DRAWINGS

[0047] Figure 1 Flowchart of the behavior tree-based autonomous driving testing method.

[0048] Figure 2 A schematic diagram of a test sub-scenario provided in an embodiment of the present application.

[0049] Figure 3 A schematic diagram of another test sub-scenario provided in an embodiment of the present application.

[0050] Figure 4 A schematic diagram of the timing logic relationship provided in an embodiment of the present application.

[0051] Figure 5 An embodiment of the present application provides a behavior directed graph.

[0052] Figure 6 Another behavior directed graph provided by an embodiment of the present application.

[0053] Figure 7 Schematic diagram of the behavior tree creation process provided in an embodiment of the present application.

[0054] Figure 8 A diagram of a behavior tree provided in an embodiment of the present application.

[0055] Figure 9 Block diagram of an autonomous driving test setup based on behavior trees. DETAILED DESCRIPTION

[0056] The following will clearly and completely describe the technical solutions in the embodiments of the present invention in conjunction with the accompanying drawings. Obviously, the embodiments described are only specific embodiments of the present invention, not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of the present invention.

[0057] The automatic driving test method of the present invention is as follows: Figure 1 As shown, the following steps are included (steps 110 to 140).

[0058] Step 110: Acquire a test map, construct a test scenario based on the test map and select a dynamic target, obtain the atomic action set of the dynamic target and the behavior trajectory of the dynamic target in each test sub-scenario included in the test scenario.

[0059] In this step, the present invention sets the test sub-scene, dynamic target, the set of atomic actions constituting the dynamic target, and the behavior trajectory of the dynamic target based on the acquired test map, including the following sub-steps (111 to 115).

[0060] Step 111: Get a test map.

[0061] For autonomous driving simulation testing, the test maps obtained include but are not limited to: lane information (such as forward lanes, reverse lanes, leading lanes and following lanes, etc.), intersection information (such as crossroads, T-junctions, roundabouts, etc.), overpasses, highways, traffic lights, etc.

[0062] Step 112: Construct a test scenario based on the test map.

[0063] A test scenario can include at least one test sub-scenario, which should be compatible with the test map. For example, if the test map includes lane and intersection information, the test sub-scenario constructed based on this test map may include straight lanes, curves, intersections, etc.; if the test map includes a highway, the test sub-scenario constructed based on this test map may include straight lanes, curves, etc.

[0064] Step 113: Select a dynamic target based on the test scenario.

[0065] In one example, the dynamic target may only include the object under test (test vehicle).

[0066] In another example, dynamic targets include not only the measured object but also dynamic elements. The selection of dynamic elements should be adapted to the test scenario. For example, if the test scenario includes an intersection, dynamic elements may include vehicles, pedestrians, traffic lights, and weather. If the test scenario includes a highway, dynamic elements may include traffic flow and weather.

[0067] One point that needs to be explained is that the object under test usually appears continuously during the test process, so each test sub-scenario of the test scenario contains the object under test; however, dynamic elements are other elements that appear dynamically in addition to the object under test during the test process. They can appear continuously during the test process or appear within a certain period of time during the test process. Therefore, a test sub-scenario of the test scenario may contain dynamic elements or not, and the dynamic elements in each test sub-scenario of the test scenario may be the same or different.

[0068] For example, the test map includes lane information and intersection information, and the test scenario includes two test sub-scenarios, namely Figure 2 The test sub-scenario 1 shown and Figure 3 Test sub-scenario 2 shown in Figure 2. Figure 2 and Figure 3 As shown in Figure 1, both test sub-scene 1 and test sub-scene 2 contain the object under test: the white car. Figure 2 As shown, test sub-scene 1 contains two parallel straight lanes and dynamic elements: a black car, a sunny day ( Figure 2 not shown); Figure 3 As shown, test sub-scenario 2 contains two parallel left-turn lanes and dynamic elements: pedestrians, sunny day ( Figure 3 Not shown), traffic lights ( Figure 3 not shown).

[0069] Step 114: Obtain the atomic action set of the dynamic target.

[0070] The atomic action set of the present invention refers to a set consisting of all possible executable atomic actions, and an atomic action refers to a minimum action unit.

[0071] For autonomous driving simulation testing, the set of atomic actions includes but is not limited to: atomic actions of test vehicles and vehicles (such as maintaining speed, stopping, braking, reversing, changing lanes, making U-turns, going straight, turning left, turning right, keeping lanes, breaking down, overtaking, rear-ending, cutting in, etc.), atomic actions of traffic flow (such as vehicle speed, number of vehicles in the traffic flow, intervals between vehicles, etc.), atomic actions of pedestrians and pedestrian flows (such as crossing the road, walking along the road, etc.), atomic actions of weather (such as sunny, rainy, snowy, foggy, etc.), and atomic actions of traffic lights (such as red light, yellow light, green light, etc.).

[0072] In the present invention, the atomic action set of the dynamic target can be adapted to the selected test map. For example, when the test map includes lane information (such as forward lanes, reverse lanes, leading lanes and following lanes, etc.), intersection information (such as crossroads, T-junctions, etc.), traffic lights, etc., the atomic action set can include: test vehicles, vehicles, test traffic flows, atomic actions of traffic flows; atomic actions of pedestrians and pedestrian flows; atomic actions of traffic lights.

[0073] Step 115: Obtain the behavior trajectory of the dynamic target in each test sub-scenario.

[0074] In this application, the term "preset behavior trajectory" refers to the trajectory of a dynamic target during testing. It should be understood that this refers to the route formed after setting the dynamic target's start and end points, as well as the required task points during the test (similar to navigation in an in-vehicle map), and does not include parameter information such as the speed and distance of the measured object and dynamic elements.

[0075] For example, Figure 2 As shown in the figure, for test sub-scenario 1, the preset behavior trajectory of the tested object (white car) includes: the white car goes straight in the right lane; the preset behavior trajectory of the dynamic element (black car) includes: the black car goes straight in the left lane first, then changes lanes to the right lane, and then goes straight for a distance in the right lane after changing lanes. For another example, Figure 3 As shown, for test sub-scenario 2, the preset behavior trajectory of the tested object (white car) includes: the white car first goes straight and then turns left at the intersection; the preset behavior trajectory of the dynamic element (pedestrian) includes: the pedestrian first waits at the intersection and then crosses the road.

[0076] Similarly, in this application, the preset behavior trajectory can be adapted to the selected test map, or in other words, matched to the structure of the test map. For example, if the test map includes a straight lane and an intersection, then when the test map has a straight lane followed by an intersection, since a right turn cannot be performed in the straight lane, the preset behavior trajectory should include: first going straight, then turning right at the intersection.

[0077] It should be noted that the present application does not limit the order of execution of step 114 and step 115. Step 114 can be executed before step 115, after step 115, or simultaneously with step 115.

[0078] Step 120: Based on the atomic action set, decompose the behavior trajectory into at least one atomic action, and determine the temporal logical relationship of the atomic actions.

[0079] In this step, the present invention constructs the temporal logic relationship of the atomic actions of different dynamic targets in each test sub-scenario based on the atomic action set and the behavior trajectory of the dynamic target obtained above. The temporal logic relationship of the atomic action includes at least one of: atomic action serial, atomic action parallel and atomic action repetition. The seriality of atomic actions means that two atomic actions are executed one after another in time, for example, Figure 4 As shown in , atomic action 2 is executed after atomic action 1 is completed; the parallelism of atomic actions means that the execution time of two atomic actions overlaps, for example, Figure 4 As shown, atomic action 1 and atomic action 2 are executed at the same time, or atomic action 1 is executed for a period of time before atomic action 2 is executed; repetition of atomic action means that atomic action is executed repeatedly, for example, Figure 4 As shown, after atomic action 1 is completed, atomic action 1 is executed again.

[0080] First, the computer device can decompose the preset behavior trajectory of the dynamic target into multiple atomic actions based on the atomic actions included in the atomic action set. Figure 2 As shown in FIG1 , for test sub-scenario 1, based on the preset behavior trajectory of the tested object (white car), the atomic actions of the white car can be decomposed into: going straight (maintaining speed); based on the preset behavior trajectory of the dynamic element (black car), the atomic actions of the black car can be decomposed into: going straight (maintaining speed), changing lanes to the right, going straight, braking, and stopping; Figure 3 As shown, for test sub-scenario 2, the preset behavior trajectory of the object under test (white car) can be decomposed into the atomic actions of the white car, including: going straight and turning left. The preset behavior trajectory of the dynamic element (pedestrian) can be decomposed into the atomic actions of the pedestrian, including: waiting and crossing the road (fixed speed).

[0081] Afterwards, in each test sub-scenario, the temporal logic relationship of the atomic actions of each dynamic target is determined according to the above-mentioned behavior trajectory decomposition results.

[0082] like Figure 2 As shown in Figure 1, for test sub-scenario 1, the temporal logic relationship of the atomic actions of the tested object (blue car) is the repetition of the atomic action of "going straight (maintaining speed)", and the temporal logic relationship of the atomic actions of the dynamic element (red car) is the series of atomic actions of "going straight (maintaining speed), changing lanes to the right, going straight, braking, and stopping". Figure 3 As shown, for test sub-scenario 2, the temporal logical relationship of the atomic actions of the object under test (blue car) is a series of atomic actions such as "going straight, turning left", and the temporal logical relationship of the atomic actions of the dynamic element (pedestrian) is a series of atomic actions such as "waiting, crossing the road (fixed speed)".

[0083] Step 130: Combine the temporal logic relationships in each test sub-scenario, and create a behavior tree corresponding to the test scenario based on the combination results.

[0084] Combining the temporal logic relationship in each test sub-scenario includes steps 131 and 132 ; and creating a behavior tree corresponding to the test scenario based on the combination result includes steps 133 to 135 .

[0085] Step 131: Combine the same dynamic target in each test sub-scene.

[0086] The object under test usually appears continuously during the test process, so the object under test will appear in each test sub-scenario of the test scenario. In other words, the same object under test usually appears in multiple test sub-scenarios. The present invention needs to merge the same object under test in different test sub-scenarios. For example, Figure 2 and Figure 3 As shown, the object under test (white car) appears in both test sub-scene 1 and test sub-scene 2, so the objects under test (white car) in test sub-scene 1 and test sub-scene 2 need to be merged.

[0087] Dynamic elements appear dynamically during the test process. Therefore, the same dynamic element may appear in only one test sub-scenario of a test scenario, or it may appear in multiple test sub-scenarios within the test scenario. If the same dynamic element appears in multiple test sub-scenarios, it needs to be merged across the multiple test sub-scenarios.

[0088] Step 132: Combine the temporal logic relationships of the atomic actions of different dynamic targets in each test sub-scenario to obtain a combination result.

[0089] The temporal logic relationships of the atomic actions of different test objects and dynamic elements in various test sub-scenarios can be combined to form a comprehensive combination of the temporal logic relationships of multiple test objects, multiple dynamic elements, and multiple types of atomic actions in multiple test sub-scenarios. When combining the temporal logic relationships of the atomic actions in various test sub-scenarios, newly added dynamic elements in different test sub-scenarios should be added, and those that do not appear should be deleted.

[0090] For example, based on Figure 2 The test sub-scenario 1 shown and based on Figure 3 The temporal logic relationship of the atomic actions combined by the test sub-scenario 2 shown is as follows: in test sub-scenario 1, the straight-line movement (maintaining speed) of the tested object (white car) and the straight-line movement (maintaining speed) of the dynamic element (black car) are parallel atomic actions, and the straight-line speed of the black car is slightly greater than that of the white car. The straight-line movement (maintaining speed) of the white car and the lane change to the right, straight-line movement, braking, and stopping of the black car are parallel atomic actions; in test sub-scenario 2, the straight-line movement of the white car and the right turn of the white car are serial atomic actions, the right turn of the white car and the waiting of the dynamic element (pedestrian, at this time, the black car needs to be deleted and the pedestrian needs to be added) are parallel atomic actions, and the waiting of the pedestrian and the pedestrian crossing the road (fixed speed) are serial atomic actions.

[0091] In this application, since the map information and dynamic elements of different test sub-scenes may be different, in order to smooth the interface display effect when switching between different test sub-scenes, transition scenes can be appropriately added between different test sub-scenes, which can also make the combined atomic actions more consistent with the actual scene. Based on this, in one example, the method provided by the present invention also includes: based on any two adjacent test sub-scenes and the behavior trajectory of the dynamic target in the test sub-scene, constructing a transition scene and the behavior trajectory of the dynamic target in the transition scene; wherein the test scene includes a test sub-scene and a transition scene. Optionally, the transition scene includes but is not limited to a map transition scene and a behavior transition scene. The map transition scene refers to adding a new map information between two map information, and the behavior transition scene refers to adjusting the speed, lane, position, etc. of the tested object and the dynamic element.

[0092] For example, based on Figure 2 The test sub-scenario 1 shown and based on Figure 3 The test sub-scenario 2 shown can add a transition scene 3 between test sub-scenario 1 and test sub-scenario 2. The map transition scene of the transition scene 3 can be: a straight section, and the behavior transition scene can be: the object under test (white car) changes lanes to bypass the stopped dynamic element (black car) and accelerates to the fixed speed of the white car when it is going straight in test sub-scenario 2.

[0093] Step 133: Based on the temporal logic relationship, mark the behavior directed identifiers between the atomic actions, and generate a behavior directed graph according to the behavior directed identifiers.

[0094] In view of the differences in temporal logic relationships, the present invention uses the following methods to mark the behavior-directed identifiers between atomic actions:

[0095] For serial atomic actions, the atomic action A with the earlier start execution time is set as the predecessor node, and the atomic action B with the later start execution time is set as the successor node of atomic action A. The end execution time of the predecessor node is the start execution time of the successor node, and the behavior directed identifier points from atomic action A to atomic action B.

[0096] For parallel atomic actions, if the start execution time of two or more atomic actions (taking atomic action B and atomic action C as examples) is the same, then atomic action B and atomic action C are set as parallel nodes in the behavior directed graph; if the start execution time of multiple parallel atomic actions (taking atomic action B and atomic action C as examples) is the end execution time of a certain atomic action (taking atomic action A as an example), then atomic action B and atomic action C are both used as successor nodes of atomic action A, and the behavior directed identifier is pointed from atomic action A to atomic action B and atomic action C respectively.

[0097] For repeated atomic actions, taking the repeated execution of atomic action A as an example, atomic action A is set as the successor node of atomic action A, the end execution time of atomic action A is the start execution time of the second execution of atomic action A, and the directed identifier points from atomic action A to atomic action A.

[0098] After obtaining the directed behavioral identifiers between the atomic actions, they are matched one-to-one according to the temporal logic relationship, thereby generating a directed behavioral graph of the temporal logic relationship.

[0099] For example, based on Figure 2 The test sub-scenario 1 shown and based on Figure 3 The test sub-scenario 2 shown in FIG. 1 and the transition scenario 3 added between the test sub-scenario 1 and the test sub-scenario 2 can be obtained as follows: Figure 5 Of course, before scheduling the behavior of the tested object and dynamic elements through the behavior tree, the test scenario needs to be initialized first. Figure 5 As shown, the test scenario initialization setting test scenario can be used as the first atomic action to be executed and added to the behavior directed graph. For other introductions to the atomic action of test scenario initialization setting test scenario, please refer to the following embodiment, which will not be repeated here.

[0100] Step 134: Construct an adjacency matrix of the behavior directed graph by determining whether each atomic action in the behavior directed graph has a successor node.

[0101] The rows of the adjacency matrix represent the atomic actions of each node in the behavioral directed graph, and the columns of the adjacency matrix represent whether the atomic action corresponding to the row of the adjacency matrix has a successor node. For example, 0 indicates that the atomic action in this row has no corresponding successor node, and 1 indicates that the atomic action in this row has a corresponding successor node.

[0102] For example, by Figure 6 The behavioral directed graph shown in Table 1 can generate the adjacency matrix shown in Table 1.

[0103] Table 1 Adjacency matrix

[0104] start Atomic Action 1 Atomic Action 2 Atomic Action 3 Atomic Action 4 Atomic Action 5 Finish Atomic Action 1 0 1 1 0 0 0 Atomic Action 2 0 0 0 0 0 0 Atomic Action 3 0 0 0 0 1 0 Atomic Action 4 0 0 0 0 1 0 Atomic Action 5 0 0 0 0 0 1 Finish 0 0 0 0 0 0

[0105] For example, by Figure 5 The behavioral directed graph shown in Table 2 can generate the adjacency matrix.

[0106] Table 2 Adjacency matrix

[0107]

[0108]

[0109] Step 135: Create a behavior tree corresponding to the test scenario based on the adjacency matrix and the behavior tree creation conditions.

[0110] A directed behavior graph is used to describe the behavior of the object under test and dynamic elements. Based on the adjacency matrix corresponding to the directed behavior graph, a behavior tree for the object under test and dynamic elements can be created, that is, the behavior tree corresponding to the test scenario. When creating a behavior tree, the following behavior tree creation conditions must be followed:

[0111] (1) A Sequence parent node needs to be added before each atomic action shown in the adjacency matrix;

[0112] (2) Among the atomic actions shown in the adjacency matrix, if an atomic action A has only one successor node (taking atomic action B as an example), then the successor node (atomic action B) is regarded as the child node of the sequential parent node of atomic action A;

[0113] (3) If an atomic action A has multiple successor nodes (taking atomic action B and atomic action C as an example), all successor nodes (atomic action B and atomic action C) are treated as child nodes of a parallel parent node, and the parallel parent node is treated as a child node of the sequential parent node of atomic action A;

[0114] (4) Among the atomic actions shown in the adjacency matrix, if an atomic action E has multiple predecessor nodes (taking atomic action C and atomic action D as an example), the states of all predecessor nodes (atomic action C and atomic action D) are taken as a trigger event, and the trigger event is used as the new predecessor node of atomic action E. Atomic action E and its successor nodes and the new predecessor node will form a new subtree and serve as a child node of the root node;

[0115] (5) If an atomic action E has no predecessor node, then the atomic action E is treated as a child node of a parallel node, which is the root node of the behavior tree.

[0116] It is important to note that, since a sequential parent node is added before each atomic action in condition (1), the atomic actions described in conditions (2)-(5) are actually atomic actions with sequential parent nodes added. Furthermore, the behavior tree creation process can be executed in the order of conditions (1), (2), (3), (4), and (5), or in the order of conditions (5), (4), (3), (2), and (1), or in the order of conditions (1), (3), (5), (2), and (4), etc. This invention does not limit this.

[0117] For example, please refer to Figure 7 , which shows a process of creating a behavior tree based on the adjacency matrix shown in Table 1. Figure 7 As shown in (a), first, a sequential parent node can be added before each atomic action shown in Table 1; then, Figure 7 As shown in (b), for an atomic action with a successor node, the successor node is used as a child node of the sequential parent node of the atomic action (the atomic action described here is actually an atomic action with a sequential parent node added) (such as atomic action 5 and end). If there are multiple successor nodes, these multiple successor nodes are used as child nodes of a parallel parent node, and the parallel parent node is used as a child node of the sequential parent node of the atomic action (such as atomic action 1, atomic action 2 and atomic action 3); then, as Figure 7 As shown in (c), for an atomic action with multiple predecessor nodes, these multiple predecessor nodes are treated as a trigger event, and the trigger event is used as the new predecessor node of the atomic action. Then, the atomic action and its successor nodes (atomic action 5 and end) and the new predecessor node form a new subtree and serve as a child node of the root node (such as atomic action 3, atomic action 4 and atomic action 5). In addition, as Figure 7 As shown in (c), for an atomic action that does not have any predecessor node, the atomic action is used as a child node (such as start) of a parallel node (root node). Figure 7 (c) is the behavior tree created based on the adjacency matrix shown in Table 1.

[0118] For example, it is possible to use Figure 7 The same creation process of the behavior tree shown in Table 2 is used to create the behavior tree of the tested object and dynamic elements based on the adjacency matrix shown in Table 2. The created behavior tree is as follows Figure 8 shown.

[0119] Step 140: Run the behavior tree to obtain the autonomous driving test result of the tested object.

[0120] In the present invention, step 140 includes the following steps 141 and 142 .

[0121] Step 141: Create and initialize a behavior subtree, and start the timer and listener of the behavior subtree.

[0122] When running a behavior tree, you need to create a behavior subtree and call its initialization function to initialize it. After initializing the behavior subtree, you start its timer and listener. The behavior subtree timer records the runtime of the entire behavior tree; the behavior subtree listener monitors any exceptions that may occur during the behavior tree's execution, such as a simulation engine connection failure, the crash or loss of control of the test object, memory leaks, or other system service anomalies.

[0123] Step 142: Pre-order traverse each node of the behavior tree, run the node corresponding to the atomic action, and determine whether the running behavior of the node meets the completion condition of the atomic action corresponding to the node, so as to obtain the running status of the node.

[0124] Pre-order traversal means first visiting the root node, then traversing the left subtree, and finally traversing the right subtree. When traversing the left and right subtrees, the root node is visited first, then the left subtree, and finally the right subtree. Therefore, in this application, the start node in the behavior tree is executed first, followed by the node corresponding to atomic action 1 in the behavior tree.

[0125] Run the node corresponding to atomic action 1, that is, set up the test scene. Setting up the test scene includes: importing the test map, and generating the tested objects and dynamic elements in the test map. Among them, the traffic lights, weather and other elements in the dynamic elements are introduced when executing the atomic action of setting up the test scene. The time of the red light, yellow light, and green light of the traffic light, as well as the weather, etc. can be set. The elements such as vehicles and pedestrians in the dynamic elements can be rendered uniformly when setting up the test scene, or they can be rendered when running to the corresponding test sub-scene. For example, Figure 2 and Figure 3 As an example, the test sub-scenario shown in the figure is Figure 2The test sub-scene shown is executed first, so when the Set Test Scene node of the behavior tree is executed, the dynamic element rendered is the black car. Subsequently, when the test sub-scene 2 is executed or is about to be executed, the pedestrian dynamic element is rendered. Of course, this application does not exclude the possibility of rendering all dynamic elements when executing the Set Test Scene node of the behavior tree.

[0126] As can be seen from the above description, setting the test scenario is the first node to be run after the start node of the behavior tree. After setting the test scenario, the behavior tree traverses other nodes in sequence in a pre-order traversal manner to achieve behavioral control of the tested object and dynamic elements. In addition, in this application, setting the test scenario can be implemented as a node of the behavior tree, such as Figure 8 The atomic action 1 in the behavior tree shown can also be implemented as multiple nodes in the behavior tree. For example, importing a test map, generating a test object, generating a dynamic element, etc. can each be an atomic action, and these atomic actions can be executed serially or in parallel through the behavior tree.

[0127] During pre-order traversal, if a node corresponding to an atomic action is reached, the node corresponding to the atomic action is executed. For serial atomic actions, the nodes corresponding to the atomic action are executed sequentially using the behavior tree in the order in which they are executed; for parallel atomic actions, the nodes corresponding to the atomic action are executed in parallel using the behavior tree. In this application, the specific steps for pre-order traversal and executing the nodes corresponding to the atomic actions of the measured object and dynamic elements are as follows:

[0128] Step 1421: When the pre-order traversal reaches the node corresponding to the atomic action, the parameters of the node are initialized.

[0129] Whenever the pre-order traversal reaches a node corresponding to the atomic action of the measured object or dynamic element, the necessary parameters of the node need to be initialized. This parameter initialization can be to initialize all parameters of the node or to initialize some parameters of the node.

[0130] Step 1422: Update the node status in real time and set the node current status to running.

[0131] Node status includes but is not limited to: running, success, and failure. In this application, the update of the node status requires first updating the behavior of the object under test and the dynamic elements, and then determining the update of the current state of the node based on the behavior update. For the application of autonomous driving simulation testing, the behaviors include but are not limited to: maintaining vehicle speed, stopping, braking, reversing, changing lanes, making U-turns, going straight, turning left, turning right, keeping lanes, breaking down, overtaking, rear-ending, cutting in, etc.; the basis for determining the current state of the node includes but is not limited to: whether the distance reaches the destination, whether the object under test has collided, whether the traffic light is suitable for passage, etc.

[0132] For example, Figure 2 As shown in the test sub-scenario 1, the atomic actions obtained by decomposing the behavior of the tested object (white car) include going straight (maintaining the speed). When updating the current state of the node corresponding to the atomic action, it is necessary to determine whether the speed of the white car going straight is the specified speed; Figure 3 As shown, in test sub-scenario 2, the atomic actions obtained by decomposing the behavior of the object under test (white car) include turning left. When updating the current state of the node corresponding to the atomic action, it is necessary to determine whether the white car collides with a pedestrian when turning left.

[0133] In one example, when updating a node's current state, the node's current state data can be recorded. This data includes, but is not limited to, the current speed and position (such as XY coordinates or latitude and longitude) of the measured object, lane, etc. Optionally, a "blackboard mechanism" can be used to record the node's current state data. The data recorded on the blackboard is the common data between behaviors in the behavior tree. Each node needs to read and write data on the blackboard at runtime, which can be implemented in the form of a key-value store with global access rights.

[0134] For example, when running nodes corresponding to atomic actions, you can use behavior trees to control the behavior of the measured object and dynamic elements. The following shows a possible way to control behavior through a behavior tree:

[0135] (1) Use velocity and direction to describe the atomic motion of the measured object and dynamic elements.

[0136] In terms of speed, it is necessary to describe the numerical value of the speed of the measured object and dynamic elements and the speed change. Therefore, the content obtained by using speed to describe atomic actions includes but is not limited to: acceleration, deceleration, maintaining vehicle speed, reverse gear, braking, stopping, etc.; in terms of direction, it is necessary to combine road information to describe the direction change of the measured object and dynamic elements. Therefore, the content obtained by using direction to describe atomic actions includes but is not limited to: changing lanes to the left, changing lanes to the right, keeping lane, turning left, turning right, U-turn, going straight, etc.

[0137] (2) Set the speed-related atomic actions to the speed subtree and use the speed subtree to control the speed.

[0138] The speed subtree includes speed setting atomic actions and speed determination atomic actions. The speed setting atomic action transmits the target speed through the controller. The controller calculates parameters such as throttle and brake based on the current speed and the target speed, and applies these parameters to the vehicle to control its speed. The speed determination atomic action obtains the vehicle's speed from the data pool to determine whether the action is completed.

[0139] (3) Set the atomic actions related to the orientation as the direction subtree, and use the direction subtree to control driving.

[0140] The direction subtree transmits the direction through the controller and obtains the target point from the data pool. The controller plans the driving route according to the target direction and calculates the degree of the steering wheel. Then, by changing the degree of the steering wheel, the measured object and dynamic elements are controlled to drive according to the planned driving route.

[0141] Step 1423: When the behavior satisfies the completion condition of the atomic action, the current state of the node is set to success.

[0142] When updating the node status in real time, you need to update the behavior of the measured object and dynamic elements first. When the behavior meets the completion conditions of the current atomic action, set the current status of the node corresponding to the current atomic action to success, and the node corresponding to the atomic action is completed.

[0143] For example, Figure 2 As shown, in test sub-scenario 1, the atomic actions obtained by decomposing the behavior of the dynamic element (black car) include changing lanes to the right. The completion condition of this atomic action can be set as the black car starting to go straight. When running to the node corresponding to the atomic action, it is necessary to obtain the behavior of the black car. If the behavior of the black car is to start turning right to change lanes, the behavior of the black car does not meet the completion condition of the atomic action of changing lanes to the right. If the behavior of the black car is to start going straight, the behavior of the black car meets the completion condition of the atomic action of changing lanes to the right. At this time, the current state of the node corresponding to the atomic action can be set to success, and the node corresponding to the atomic action of changing lanes to the right is completed.

[0144] Step 1424: Terminate the execution of the node and proceed to the execution of the next node in the order of pre-order traversal.

[0145] When the node corresponding to the current atomic action completes execution, the execution of the node can be terminated, and the traversal of the next node in the behavior tree continues in the pre-order traversal order, and then the execution of the next node begins, that is, repeating steps 1421 to 1424.

[0146] After traversing all nodes of the behavior tree through steps 141 to 142 above, test data can be generated and recorded and stored locally. Of course, the test data can also be exported and processed.

[0147] In one example, when running the behavior tree, step 141 can simultaneously establish a behavior subtree and a decision subtree. The decision subtree is used to determine and evaluate the behavior tree's execution results. Therefore, step 140 in the present invention further includes: establishing a decision subtree; and, after traversing all nodes of the behavior tree, executing the decision subtree. After traversing all nodes of the behavior tree, the subject under test has completed all tasks in the test environment and enters the decision subtree to determine and evaluate the execution results. The determination and evaluation of the execution results can be based on test indicators customized by the test task, including but not limited to: whether the tester ran a red light, the number of red light runs, speeding, collision, deviation from the original route, timeout, and wrong-way driving.

[0148] To sum up, the present invention decomposes the preset behavior trajectory of the object under test and dynamic elements into multiple atomic actions based on the abstract atomic action set, and then combines the atomic actions of the object under test and dynamic elements in time and space based on the temporal logical relationship (serial / parallel / repetitive) of the atomic actions, which can generate a large number of rich and diverse dynamic test scenarios. Compared with the traditional technology of controlling the behavior of the object under test and dynamic elements through code, it can provide a new perspective for describing the behavior of different individuals in time and space based on temporal logical relationship. The behavior description is clearer and concise, and it is easy to reflect the behavioral interaction between different subjects.

[0149] The present invention combines test scenarios through multiple test sub-scenarios and appropriately adds transition scenarios between different test sub-scenarios. This not only enables flexible combination and construction of test scenarios to adapt to different test tasks, but also smooths the switching between different test sub-scenarios, making it more in line with actual testing and ensuring the consistency of the operation of the object under test in different test sub-scenarios.

[0150] When the present invention runs to the corresponding test sub-scenario, the dynamic elements can be flexibly deleted. Compared with the existing technology that requires the number and appearance timing of dynamic elements to be set in advance in the form of code, the dynamic elements can be made to appear dynamically in the test sub-scenario.

[0151] refer to Figure 9 , which shows a block diagram of an autonomous driving test device based on a behavior tree according to an embodiment of the present invention. The device can be a computer device or can be set in a computer device. Figure 9 As shown, the device 900 includes: a setting module 910, a generation module 920, a creation module 930 and an operation module 940.

[0152] A setting module 910 is configured to obtain a test map, construct a test scenario based on the test map, select a dynamic target, and obtain an atomic action set of the dynamic target and a behavior trajectory of the dynamic target in each test sub-scenario included in the test scenario, wherein the dynamic target includes a tested object and a dynamic element;

[0153] A generating module 920 is configured to decompose the behavior trajectory into at least one atomic action based on the set of atomic actions, and determine a temporal logical relationship of the atomic actions;

[0154] A creation module 930 is configured to combine the temporal logic relationships in each of the test sub-scenarios and create a behavior tree corresponding to the test scenario based on the combination results;

[0155] The running module 940 is used to run the behavior tree to obtain the autonomous driving test result of the tested object.

[0156] Optionally, the temporal logic relationship includes at least one of: atomic action serialization, atomic action parallelization, and atomic action repetition.

[0157] Optionally, the creation module 930 includes a temporal logic relationship combination unit, and the temporal logic relationship combination unit is configured to:

[0158] combining the same dynamic target in each of the test sub-scenarios;

[0159] The temporal logic relationship of the atomic actions of different dynamic targets in each of the test sub-scenarios is combined to obtain the combination result.

[0160] Optionally, the creation module 930 includes a behavior tree creation unit, and the behavior tree creation unit is configured to:

[0161] Based on the temporal logic relationship, marking the behavior directed identifiers between the atomic actions, and generating a behavior directed graph according to the behavior directed identifiers;

[0162] Constructing an adjacency matrix of the behavior directed graph by determining whether each of the atomic actions in the behavior directed graph has a successor node;

[0163] Create a behavior tree corresponding to the test scenario based on the adjacency matrix and behavior tree creation conditions, where the behavior tree creation conditions include:

[0164] Add a sequential parent node before the atomic action;

[0165] If an atomic action has only one successor node, the successor node is used as a child node of the sequential parent node of the atomic action;

[0166] If an atomic action has multiple successor nodes, each successor node is used as a child node of a parallel parent node, and the parallel parent node is used as a child node of the sequential parent node of the atomic action;

[0167] If an atomic action has multiple predecessor nodes, the states of all the predecessor nodes are used as a trigger event, the trigger event is used as a new predecessor node of the atomic action, and the new predecessor node is used as a child node of the root node. The new predecessor node, the atomic action, and the successor node of the atomic action are combined into a new subtree;

[0168] If an atomic action has no predecessor node, the atomic action is used as a child node of a parallel node, and the parallel node is used as the root node of the behavior tree.

[0169] Optionally, the operation module 940 is configured to:

[0170] Create and initialize a behavior subtree, and start a timer and listener for the behavior subtree. The timer is used to record the running time of the behavior tree, and the listener is used to monitor abnormal situations that occur during the running of the behavior tree.

[0171] The pre-order traversal is performed on each node of the behavior tree, the node corresponding to the atomic action is executed, and it is determined whether the execution behavior of the node satisfies the completion condition of the atomic action corresponding to the node, so as to obtain the execution status of the node.

[0172] Optionally, the operation module 940 is further configured to:

[0173] Establishing a decision subtree, wherein the decision subtree is used to determine and evaluate the running result of the behavior tree;

[0174] When all nodes of the behavior tree are traversed, the decision subtree is executed.

[0175] Optionally, the device 900 also includes a transition scene construction module 950, which is used to: construct a transition scene and the behavior trajectory of the dynamic target in the transition scene based on any two adjacent test sub-scenes and the behavior trajectory of the dynamic target in the test sub-scene; wherein the test scene includes the test sub-scene and the transition scene.

[0176] For an explanation of the specific execution process, beneficial effects, etc. of the device module, please refer to the introduction of the above method embodiment, which will not be elaborated here.

[0177] In an exemplary embodiment, a computer device is further provided, comprising a memory and a processor, wherein a computer program is stored in the memory, and the computer program is loaded and executed by the processor to implement the above-mentioned behavior tree-based autonomous driving test method.

[0178] In an exemplary embodiment, a computer-readable storage medium is further provided, on which a computer program is stored. When the computer program is executed by a processor, the autonomous driving test method based on the behavior tree as described above is implemented.

[0179] In an exemplary embodiment, a computer program product is further provided. When the computer program product is run on a computer device, the computer device executes the above-mentioned behavior tree-based autonomous driving testing method.

[0180] The above description is only a preferred embodiment of the present invention and is not intended to limit the present invention. Any modifications, equivalent substitutions, improvements, etc. made within the spirit and principles of the present invention should be included in the scope of protection of the present invention.

Claims

1. A behavior tree-based autonomous driving testing method, characterized in that: The method comprises: Acquire a test map, construct a test scenario based on the test map and select a dynamic target, obtain an atomic action set of the dynamic target and a behavior trajectory of the dynamic target in each test sub-scenario included in the test scenario, wherein the dynamic target includes a tested object and a dynamic element; Based on the atomic action set, decomposing the behavior trajectory into at least one atomic action, and determining the temporal logical relationship of the atomic actions; Combining the temporal logic relationships in each of the test sub-scenarios and creating a behavior tree corresponding to the test scenario based on the combination results; wherein creating the behavior tree corresponding to the test scenario includes: Based on the temporal logic relationship, marking the behavior directed identifiers between the atomic actions, and generating a behavior directed graph according to the behavior directed identifiers; Constructing an adjacency matrix of the behavior directed graph by determining whether each of the atomic actions in the behavior directed graph has a successor node; Create a behavior tree corresponding to the test scenario based on the adjacency matrix and behavior tree creation conditions, where the behavior tree creation conditions include: Add a sequential parent node before each of the atomic actions; If an atomic action has only one successor node, the successor node is used as a child node of the sequential parent node of the atomic action; If an atomic action has multiple successor nodes, each successor node is used as a child node of a parallel parent node, and the parallel parent node is used as a child node of the sequential parent node of the atomic action; If an atomic action has multiple predecessor nodes, the states of all the predecessor nodes are used as a trigger event, the trigger event is used as a new predecessor node of the atomic action, the new predecessor node is used as a child node of the root node, and the new predecessor node, the atomic action, and the successor node of the atomic action are formed into a new subtree; If an atomic action has no predecessor node, then use the atomic action as a child node of a parallel node, and use the parallel node as the root node of the behavior tree; The behavior tree is run to obtain an autonomous driving test result of the tested object.

2. The method according to claim 1, wherein The temporal logic relationship includes at least one of: atomic action serialization, atomic action parallelization, and atomic action repetition.

3. The method according to claim 1, wherein The combining of the temporal logic relationships in each of the test sub-scenarios includes: combining the same dynamic target in each of the test sub-scenarios; The temporal logic relationship of the atomic actions of different dynamic targets in each of the test sub-scenarios is combined to obtain the combination result.

4. The method according to claim 1, wherein Running the behavior tree includes: Create and initialize a behavior subtree, and start a timer and listener for the behavior subtree. The timer is used to record the running time of the behavior tree, and the listener is used to monitor abnormal situations that occur during the running of the behavior tree. The pre-order traversal is performed on each node of the behavior tree, the node corresponding to the atomic action is executed, and it is determined whether the execution behavior of the node satisfies the completion condition of the atomic action corresponding to the node, so as to obtain the execution status of the node.

5. The method according to claim 1, wherein Running the behavior tree further includes: Establishing a decision subtree, wherein the decision subtree is used to determine and evaluate the running result of the behavior tree; When all nodes of the behavior tree are traversed, the decision subtree is executed.

6. The method according to any one of claims 1 to 5, characterized in that The method further comprises: Based on any two adjacent test sub-scenarios and the behavior trajectory of the dynamic target in the test sub-scenarios, a transition scene and the behavior trajectory of the dynamic target in the transition scene are constructed; wherein the test scene includes the test sub-scenarios and the transition scene.

7. An autonomous driving test device based on behavior tree, characterized in that: include: A setting module is configured to obtain a test map, construct a test scenario based on the test map, select a dynamic target, and obtain an atomic action set of the dynamic target and a behavior trajectory of the dynamic target in each test sub-scenario included in the test scenario, wherein the dynamic target includes a tested object and a dynamic element; A generating module, configured to decompose the behavior trajectory into at least one atomic action based on the set of atomic actions, and determine a temporal logical relationship of the atomic actions; A creation module is configured to combine the temporal logic relationships in each of the test sub-scenarios and, based on the combination results, create a behavior tree corresponding to the test scenario; wherein creating the behavior tree corresponding to the test scenario includes: Based on the temporal logic relationship, marking the behavior directed identifiers between the atomic actions, and generating a behavior directed graph according to the behavior directed identifiers; Constructing an adjacency matrix of the behavior directed graph by determining whether each of the atomic actions in the behavior directed graph has a successor node; Create a behavior tree corresponding to the test scenario based on the adjacency matrix and behavior tree creation conditions, where the behavior tree creation conditions include: Add a sequential parent node before each of the atomic actions; If an atomic action has only one successor node, the successor node is used as a child node of the sequential parent node of the atomic action; If an atomic action has multiple successor nodes, each successor node is used as a child node of a parallel parent node, and the parallel parent node is used as a child node of the sequential parent node of the atomic action; If an atomic action has multiple predecessor nodes, the states of all the predecessor nodes are used as a trigger event, the trigger event is used as a new predecessor node of the atomic action, the new predecessor node is used as a child node of the root node, and the new predecessor node, the atomic action, and the successor node of the atomic action are formed into a new subtree; If an atomic action has no predecessor node, then use the atomic action as a child node of a parallel node, and use the parallel node as the root node of the behavior tree; The running module is used to run the behavior tree to obtain the autonomous driving test result of the tested object.

8. A computer device, characterized in that: The method comprises a memory and a processor, wherein the memory stores a computer program, and the processor is configured to run the computer program to perform the method according to any one of claims 1 to 6.

9. A storage medium storing a computer program, wherein: The computer program is configured to execute the method according to any one of claims 1 to 6 when executed.

Images