Ontology-based automatic driving simulation test method and device

Abstract

The invention provides a method for an automatic driving simulation test. The method comprises the following steps: importing an automatic driving test scene body corresponding to an automatic driving test scene simulation standard; generating a specific test scene body instance according to the automatic driving test scene body and a specific test scene demand; and according to the specific test scene ontology instance, generating a specific test scene file conforming to the automatic driving test scene simulation standard.

Description

Technical Field

[0001] The present disclosure generally relates to autonomous driving simulation testing technology, and more particularly to an ontology-based method and apparatus for generating autonomous driving test scenarios. Background Art

[0002] As one of the future development trends of the automotive industry, autonomous driving technology has witnessed rapid development in recent years. Compared with traditional manual driving, autonomous driving technology can reduce the impact of human factors such as fatigue driving and inattentiveness on traffic safety. Autonomous driving technology can also avoid vehicle collisions in a timely manner through precise perception and control systems, thereby effectively reducing the incidence of traffic accidents and improving the safety of vehicle driving. However, due to the complexity of the autonomous driving environment, very high requirements are also imposed on the safety and reliability of the autonomous driving technology itself. A large number of tests need to be carried out on autonomous driving technology to cover as many driving scenarios and traffic environments as possible. Before an autonomous driving vehicle can be put on the road normally, it usually requires billions or even tens of billions of kilometers of actual road tests. This will result in high R & D and testing costs, consume a large amount of time, delay the development of autonomous driving technology, and it is also difficult to cover rare or complex traffic environment scenarios. Therefore, autonomous driving test simulation has become an important test means in the development process of autonomous driving technology.

[0003] By simulating autonomous driving test scenarios, various required test scenarios can be provided, so as to conduct virtual autonomous driving tests in a shorter time and at a lower cost. Currently, the software platforms mainly used for autonomous driving test simulation include PreScan, CarMaker, CarSim, VTD (Virtual Test Drive), etc. These simulation platforms all provide graphical editors to generate virtual autonomous driving test scenarios. Users can use the component libraries provided by the platforms to build the required test scenarios and set specific parameter values for the corresponding components to generate specific test scenarios. For different specific test scenarios, it is necessary to manually modify the specific parameters of each component, which is very time-consuming and inefficient. It is difficult to cover various different parameters required for test scenarios by using the graphical tools provided by these software platforms to build test scenarios, and the built test scenarios are also difficult to be transplanted between various different software platforms. Therefore, a method for efficiently generating autonomous driving test scenarios is needed. Summary of the Invention

[0004] A brief description of one or more aspects in accordance with the present disclosure is provided below to give a basic understanding of these aspects. This Summary is not an extensive overview of all aspects, nor is it intended to identify key elements of all aspects or to delineate the scope of any or all aspects. Its sole purpose is to present some concepts of one or more aspects in a simplified form as a prelude to the more detailed description that follows.

[0005] According to one aspect of the present disclosure, a method for autonomous driving simulation testing is provided. The method includes: importing an autonomous driving test scenario ontology corresponding to an autonomous driving test scenario simulation standard; generating a specific test scenario ontology instance according to the autonomous driving test scenario ontology and specific test scenario requirements; and generating a specific test scenario file that conforms to the autonomous driving test scenario simulation standard according to the specific test scenario ontology instance.

[0006] According to another aspect of the present disclosure, a device for autonomous driving simulation testing is provided. The device may include a memory and at least one processor coupled to the memory. The at least one processor may be configured to: import an autonomous driving test scenario ontology corresponding to an autonomous driving test scenario simulation standard; generate a specific test scenario ontology instance according to the autonomous driving test scenario ontology and specific test scenario requirements; and generate a specific test scenario file that conforms to the autonomous driving test scenario simulation standard according to the specific test scenario ontology instance.

[0007] According to another aspect of the present disclosure, a computer-readable medium storing computer program code for autonomous driving simulation testing is provided. When executed by a processor, the computer program code may cause the processor to import an autonomous driving test scenario ontology corresponding to an autonomous driving test scenario simulation standard; generate a specific test scenario ontology instance according to the autonomous driving test scenario ontology and specific test scenario requirements; and generate a specific test scenario file that conforms to the autonomous driving test scenario simulation standard according to the specific test scenario ontology instance.

[0008] According to another aspect of the present disclosure, a computer program product for autonomous driving simulation testing is provided. The computer program product may include processor-executable computer program code for: importing an autonomous driving test scenario ontology corresponding to an autonomous driving test scenario simulation standard; generating a specific test scenario ontology instance according to the autonomous driving test scenario ontology and specific test scenario requirements; and generating a specific test scenario file that conforms to the autonomous driving test scenario simulation standard according to the specific test scenario ontology instance.

[0009] It should be noted that one or more of the above aspects include the features specifically recited in the following detailed description and in the claims. The following specification and drawings elaborate on some exemplary features in multiple aspects. These features merely indicate various ways in which the principles of each aspect can be implemented, and the present disclosure is intended to include all such aspects and their equivalent transformations. Description of the Drawings

[0010] The following drawings illustrate various embodiments of the present disclosure for illustrative purposes only. Those skilled in the art will readily recognize from the following description that alternative embodiments of the methods and structures disclosed herein can be implemented without departing from the spirit and principles of the disclosure described herein.

[0011] Figure 1 A schematic diagram showing an autonomous driving test scenario according to an embodiment of the present disclosure.

[0012] Figure 2 A flowchart showing a method for autonomous driving test simulation according to an embodiment of the present disclosure.

[0013] Figure 3 A schematic diagram showing the hierarchical structure of an autonomous driving test scenario ontology according to an embodiment of the present disclosure.

[0014] Figure 4 A schematic diagram showing the hierarchical structure of an autonomous driving test scenario ontology according to another embodiment of the present disclosure.

[0015] Figures 5-6 A schematic diagram showing the knowledge graph of a specific test scenario according to an embodiment of the present disclosure.

[0016] Figure 7 A block diagram showing a device for autonomous driving test simulation according to an embodiment of the present disclosure. Detailed Description of the Embodiments

[0017] In the following description, numerous specific details are set forth to provide a thorough understanding of the embodiments of the present invention. However, those skilled in the relevant art will recognize that the present invention can be practiced without one or more of the specific details, or alternative methods, components, etc. can be used to practice the present invention. In some instances, well-known structures and operations are not shown or described in detail to avoid unnecessarily obscuring the present invention.

[0018] Autonomous vehicle testing is a crucial part in the R & D process of autonomous driving technology. With the improvement of the autonomous driving level of intelligent connected vehicles and their gradual entry into the industrialization stage, the dependence on autonomous driving technology testing has become deeper, the importance of autonomous driving testing has become increasingly prominent, and at the same time, higher requirements have been put forward for testing technologies (such as in terms of scenario coverage, etc.). Scenarios are an important part of autonomous driving testing technology. The diversity, coverage, typicality, etc. of test scenarios will affect the accuracy of test results, thus affecting the safety of autonomous driving technology.

[0019] An autonomous driving scenario refers to the combination of traffic environment and driving situation, including various factors such as roads, traffic, weather, and lighting. These factors together constitute the concept of a scenario. A scenario is a comprehensive reflection of the environment and driving behavior within a certain time and space range, describing external states such as roads, traffic facilities, meteorological conditions, and traffic participants, as well as information such as the driving tasks and states of the host vehicle. From the perspective of the traffic environment, scenarios can be divided into highways, urban roads, rural roads, closed campuses, etc. From the perspective of driving situations, scenarios can be divided according to driving tasks or driving modes, etc. For example, according to different driving modes, scenarios can be divided into sport mode, economy mode, etc.

[0020] Whether it is actual road testing of autonomous driving or virtual simulation testing of autonomous driving, it is based on a scenario library. By testing specific required scenarios, corresponding test data can be obtained for analysis. Autonomous driving test scenarios are the basis of autonomous driving testing, which can provide effective verification for autonomous driving technology and important basis for autonomous driving vehicles to go on the road. Although actual road testing is the most reliable and accurate test method, its time and economic costs are too high, and it also has various limitations, such as legal regulations restrictions, and it is difficult to reproduce extreme traffic conditions and dangerous scenarios, etc. Therefore, scenario-based virtual simulation testing is the future development trend and an inevitable link in autonomous driving technology testing.

[0021] Autonomous driving simulation testing refers to testing an autonomous driving vehicle in a virtual scenario on a computer. Simulation testing can test the perception, decision-making, and control capabilities of an autonomous driving vehicle in various virtual scenarios. Simulation testing can reproduce various required scenarios through simulation test scenarios, thereby testing potential problems of autonomous driving technology, avoiding problems from entering subsequent testing links, and thus improving development efficiency and reducing the risk of actual road testing.

[0022] During the process of autonomous driving simulation testing, it is necessary to first determine the scenarios to be tested. The requirements for test scenarios can be proposed by the developers of the autonomous driving system to be tested, by relevant standardization organizations, by relevant government departments, or stipulated according to relevant laws and regulations. The requirements for test scenarios can be described using natural language.

[0023] Figure 1 FIG. shows a schematic diagram of an autonomous driving test scenario 100 according to an embodiment of the present disclosure. As Figure 1 shown, the test scenario 100 includes an urban road. The road includes an intersection, and there are two lanes on the left and right in each of the four directions of up, down, left, and right at the intersection, that is, lanes 122, 124, 126, 128, 132, 134, 136, and 138. A bicycle 140 is riding through the intersection in the direction from left to right. A car 150 is also traveling in the direction from bottom to top. The car 150 will reduce its traveling speed before entering the intersection and will increase its traveling speed after passing through the intersection, and then enter a normal uniform traveling state. The above is an example of a natural language description of the test scenario 100. In this example, the specific parameters of the test scenario 100 are not described, such as the width and length of each lane, the traveling speed of the bicycle, the initial traveling speed of the car, the position where the car starts to decelerate, the speed of the car when passing through the intersection, the position where the car starts to accelerate, the final traveling speed of the car, and so on. These parameters can be determined based on big data information or by test engineers based on experience.

[0024] In another example of a natural language description of the test scenario 100, it may include a description of at least some of the relevant parameters of the test scenario 100. The description of the test scenario parameters can be specific numerical values, can be a range of values, or can be a combination of the two. For example, in the natural language description of the test scenario 100, it may include at least some of the following descriptions: the traveling speed of the bicycle 140 is 20 km / h (or the traveling speed range is 10 km / h to 25 km / h), the initial traveling speed of the car 150 is 80 km / h (or the traveling speed range is 50 km / h to 90 km / h), the car 150 starts to decelerate at a position 10 m (or more than 10 m) away from the intersection, the car 150 travels through the intersection at a speed of 30 km / h (or 25 km / h to 35 km / h), and starts to accelerate at a position 10 m (or more than 10 m) away from the intersection and finally continues to travel normally at a speed of 80 km / h (or 50 km / h to 90 km / h).

[0025] Test scenario 100 is merely a simple scenario illustration. The actual test scenario can be more complex and include more elements. For example, the road in the test scenario can include more lanes in each driving direction (e.g., four lanes in one direction), and can also include curved lanes, branching lanes, uphill and downhill sections, potholes on the road surface, etc. The test scenario can include various traffic facilities, such as traffic lights, road signs, obstacles, etc. The test scenario can include the surrounding environment of the road, such as buildings and trees on both sides of the road, etc. The test scenario can include a more complex traffic environment. For example, there can be more moving vehicles and pedestrians in various different directions on the road. The behaviors of vehicles and pedestrians can also be more complex or even abnormal. For example, a vehicle may change lanes, brake suddenly, speed, etc., and a pedestrian may not walk according to the road signs or traffic lights, etc. The test scenario can also include various different natural environments, such as rain, snow, fog, wind, wind direction, lighting brightness, etc.

[0026] In order to perform the simulation of autonomous driving tests on a computer, it is necessary to convert the test scenario described in natural language into a test scenario description language and format that can be recognized and processed by a computer. Currently, there are various solutions for describing virtual test scenarios. These virtual test scenario description solutions have different formats, resulting in incompatibility between different software simulation platforms. For example, in order to achieve a unified scenario description format, the International Organization for Standardization (ISO) established an autonomous driving scenario working group and developed relevant standards for autonomous driving test scenarios. The Association for Standardization of Automation and Measuring Systems (ASAM) is also committed to promoting the standardization of the toolchain in automotive development and testing. The OpenX series of standards under ASAM for describing test scenarios have received more recognition in the industry.

[0027] The OpenX series of standards mainly include the OpenDRIVE standard for describing the static part of the test scenario, the OpenSCENARIO standard for describing the dynamic part of the test scenario, and the OpenCRG standard for describing the road surface details of the test scenario.

[0028] The OpenDRIVE standard provides a common basis for describing road networks using the syntax of Extensible Markup Language (XML), and the output file is in the format with the extension.xodr. The data stored in the OpenDRIVE file describes the geometry of the road and the features along the road, such as lanes and signals. The road network described in the OpenDRIVE file can be synthetic or real. The main purpose of the OpenDRIVE standard is to provide a description of the road network that can be input into the simulation platform and enable the exchange of these road network descriptions between different platforms. The OpenDRIVE file format is organized by nodes, and these nodes can be extended with user-defined data.

[0029] The OpenSCENARIO standard includes specifications and file architectures for describing the dynamic content in autonomous driving simulation scenarios. The main use of OpenSCENARIO is to describe complex maneuvers involving multiple vehicles. OpenSCENARIO is a description of how a scenario changes over time. In the context of vehicles and driving, a scenario includes static elements (such as road layouts and road facilities) and dynamic elements (such as weather and lighting, vehicles, objects, people, and traffic light states). OpenSCENARIO defines a data model and output file format for describing these dynamic elements. The main use case of OpenSCENARIO is to describe complex, synchronized operations involving multiple entities (such as vehicles, pedestrians, and other traffic participants). The description of a dynamic scenario can be based on driver actions, for example, performing a lane change, or on trajectories, for example, derived from recorded driving operations. The OpenSCENARIO standard provides a description method for scenarios by defining hierarchical elements from which a scenario, its attributes, and relationships are constructed. The description of dynamic elements in the OpenSCENARIO standard is organized in a hierarchical structure and is arranged in sequence using the XML language, and its output file is in the format with the extension.xosc.

[0030] Although the current mainstream software platforms for autonomous driving scenario simulation also begin to support the Open X standard, the unification of standardizing autonomous driving test scenario simulation still has a long way to go. There are still compatibility issues with the test scenario formats generated by different autonomous driving simulation software platforms. In addition, using the graphical editors provided by autonomous driving simulation software platforms to build the required test scenarios in the form of components or models requires setting various parameters manually, which brings a huge workload and is difficult to cover all specific test scenarios as comprehensively as possible.

[0031] The present disclosure provides an ontology-based autonomous driving simulation test method. Generally speaking, the method of the present disclosure can first generate an ontology for describing an autonomous driving test scenario (referred to as the autonomous driving test scenario ontology or simply the test scenario ontology in this article). The autonomous driving test scenario ontology can be repeatedly used to generate description files of specific test scenarios. When generating a description file of a specific test scenario, the method of the present disclosure can directly import the existing test scenario ontology, generate a knowledge graph of the specific test scenario by instantiating the test scenario ontology according to the test scenario requirements, and then convert the knowledge graph of the specific test scenario into a test scenario description file that conforms to the standard according to the target standard for use by downstream simulation platforms and simulation processes.

[0032] Figure 2The flowchart of method 200 for autonomous driving test simulation according to an embodiment of the present disclosure is shown. Method 200 can be used to generate a test scenario description file in a required standard format. Method 200 can be implemented by computer program code (such as Python code) and stored in a computer-readable storage medium in the form of computer program code. Method 200 can be executed by a processor as computer program code to generate a test scenario description file in a required standard format.

[0033] In step 210, method 200 can import an autonomous driving test scenario ontology corresponding to the autonomous driving test scenario simulation standard. The autonomous driving test scenario ontology can be generated according to the autonomous driving test scenario simulation standard before the import operation. That is, method 200 can directly use the previously generated test scenario ontology without regenerating the test scenario ontology every time a specific test scenario description file is generated. In some cases, if one or more elements that cannot be described by the existing test scenario ontology are included in the specific test scenario, then method 200 can also include modifying the existing test scenario ontology. For example, adding new classes or attributes to the existing test scenario ontology to expand the scope of test scenarios that the existing test scenario ontology can describe.

[0034] The autonomous driving test scenario simulation standard corresponding to the autonomous driving test scenario ontology can be the standard supported by the simulation software platform used in the subsequent simulation process (for example, ISO standard or ASAM standard), and thus can also be called the target standard. The autonomous driving test scenario simulation standard can include one or more standards in the ASAM Open X series of standards. The autonomous driving test scenario simulation standard can include: a static test scenario simulation standard for describing static test scenarios (for example, OpenDRIVE), and a dynamic test scenario simulation standard for describing dynamic test scenarios (for example, OpenSCENARIO).

[0035] The autonomous driving test scenario ontology is a description of the basic concepts and their related relationships in the autonomous driving test scenario. For example, it can be described using the Web Ontology Language (OWL) and stored as a file with the owl extension format. In an implementation using the Python language for programming, the Load() function can be used to import the test scenario ontology file. The ontology can define a semantic data model and analyze common classes and their shared properties. The autonomous driving test scenario ontology can include common classes that effectively generalize for generating autonomous driving test scenarios. The autonomous driving test scenario ontology can correspond to specific autonomous driving test scenario simulation standards and can be general for the task of generating test scenario description files that conform to the standard format. That is to say, the autonomous driving test scenario ontology may not need to be modified as the specific test scenario changes. The autonomous driving test scenario ontology can include: a static test scenario ontology corresponding to the static test scenario simulation standard (such as OpenDRIVE), and a dynamic test scenario ontology corresponding to the dynamic test scenario simulation standard (such as OpenSCENARIO). For example, the static test scenario ontology can be general for the task of generating test scenario description files in the xodr format of the OpenDRIVE standard. The dynamic test scenario ontology can be general for the task of generating test scenario description files in the xosc format of the OpenSCENARIO standard.

[0036] The hierarchical structure of the autonomous driving test scenario ontology includes multiple classes for describing the concepts in the test scenario. One or more of the multiple classes can include one or more subclasses. The classes and subclasses include object properties for describing the relationships between other classes or subclasses and data properties for describing the relationships between the classes and subclasses and their data types. The hierarchical structure used by the autonomous driving test scenario ontology to describe the test scenario and the hierarchical structure used by the corresponding autonomous driving test scenario simulation standard to describe the test scenario can be the same or different. That is to say, although the autonomous driving test scenario ontology and the corresponding autonomous driving test scenario simulation standard are used to describe test scenarios with the same scope or characteristics, such as dynamic scenarios or static scenarios, they can use different hierarchical structures to describe the same scenario. Therefore, the autonomous driving test scenario ontology can define the hierarchical structure for describing the scenario according to the habits or preferences of the developers, without being restricted by the corresponding autonomous driving test scenario simulation standard. The hierarchical structure of the autonomous driving test scenario ontology can be adjusted based on the test scenario requirements (such as the different characteristics of the scenarios to be tested).

[0037] Figure 3 A schematic diagram showing the hierarchical structure of the autonomous driving test scenario ontology according to an embodiment of the present disclosure is shown. In one embodiment, Figure 3The shown autonomous driving test scenario ontology can be an ontology corresponding to the OpenDRIVE standard for describing static test scenarios, and can also be called the OpenDRIVE ontology. As Figure 3 shown, owl:Thing 300 can be the parent class of all classes of this static test scenario ontology. The RoadNetwork class 310 can include three main classes, namely, the Road class 320, the TrafficElement class 340, and the Surrounding class 360. Although not shown, the RoadNetwork class 310 can also include one or more other classes.

[0038] The Road class 320 is a superclass that describes the segments and features of a road, and it can include subclasses such as Arms 322, Elevation 324, Curvature 326, Junction 328, and Link 330. Although not shown, the Road class 320 can also include one or more other subclasses, such as the Slope subclass, the Surface subclass, and the Bump subclass, etc. The Link subclass 330 can also include subclasses such as the Lane subclass 332 and the RoadMarking subclass 334. The TrafficElement class 340 is a superclass that describes static objects on the road that can affect traffic, and it can include subclasses such as the TrafficSign subclass 342, the TrafficLight subclass 344, and the GuidePoster subclass 346. Although not shown, the TrafficElement class 340 can also include one or more other subclasses, such as the Barrier subclass, etc. The Surrounding class 360 is a superclass that describes static objects along both sides of the road, and it can include subclasses such as the Tree subclass 362, the SignPlate subclass 364, and the GeometryOjbect subclass 366. Although not shown, the Surrounding class 360 can also include one or more other subclasses, such as the Bridge subclass (e.g., placed on the road) and the Tunnel subclass that can be defined around the road structure in the simulation, etc.

[0039] Figure 3 The solid directed connection lines in Figure 3 show the relationships between each class and subclass. There can also be relationships not shown in

[0040] Figure 4A schematic diagram showing the hierarchical structure of an autonomous driving test scenario ontology according to an embodiment of the present disclosure. In one embodiment, Figure 4 The shown autonomous driving test scenario ontology may be an ontology corresponding to the OpenSCENARIO standard for describing dynamic test scenarios, and may also be referred to as the OpenSCENARIO ontology. As Figure 4 shown, owl:Thing 400 may be the parent class of all classes of this dynamic test scenario ontology, which may include three main classes, namely, the Story class 410, the TrafficEntity class 450, and the Environment class 480.

[0041] The Story class 410 may include an Action subclass 420 and a Trigger subclass 440. The Action subclass may be used to describe various possible behaviors of traffic entities on the road, such as changing lanes, changing speed, etc. For example, the Action subclass 420 may further include a Laneoffset subclass 422, a Teleport subclass 424, a Visibility subclass 426, and a LateralDistance subclass 428. Although not shown, the Action subclass may also include one or more other subclasses, such as a Synchronize subclass, a FollowTrajectory subclass, an AssignRoute subclass, and a LongitudinalDistance subclass, etc. The Action subclass 420 may further include a PrivateAction subclass 430. The PrivateAction subclass 430 may include a RoadSet subclass 432, a SpeedSet subclass 434, and a LaneSet subclass. Although not shown, the PrivateAction subclass may also include one or more other subclasses, such as a LinkSet subclass, a PositionSet subclass, etc. As Figure 4As shown by the directed connection dotted line, objects such as the road setting subclass, speed setting subclass, lane setting subclass, connection setting subclass, and position setting subclass can be attributes of the behavior subclass. The trigger subclass can be used to describe the state that will activate another behavior. For example, the trigger subclass 440 can include the EndOfRoad subclass 442, ReachPosition subclass 444, EntitySpeed subclass 446, and Distance subclass 448. Although not shown, the trigger subclass can also include one or more other subclasses, such as the OffBoard subclass, Standstill subclass, TimeOfCollision subclass, TimeHeadway subclass, Travelled subclass, RelativeSpeed subclass, Collision subclass, and Acceleration subclass, etc.

[0042] The environment class 480 can include the TimeOfDay subclass 482, RoadCondition subclass 484, and Weather subclass 490. Although not shown, the environment class can also include one or more other subclasses. The Weather subclass 490 can include the Fog subclass 492 and Sun subclass 494. Although not shown, the Weather subclass can also include the Precipitation subclass, Cloud subclass, and Snow subclass, etc.

[0043] The traffic entity class 450 can include the Vehicle subclass 460 and Pedestrians subclass 470. The Vehicle subclass can further include the Bus subclass 462, Tram subclass 464, and Truck subclass 466. Although not shown, the Vehicle subclass can further include one or more other subclasses, such as the Van subclass, Bicycle subclass, Car subclass, Motobike subclass, Train subclass, Semitrailer subclass, and Trailer subclass, etc. The Pedestrians subclass can further include the Pedestrian subclass 472, Wheelchair subclass 474, and Animal subclass 476, etc.

[0044] Figure 4 The directed connection solid line and directed connection dotted line in [text] show the relationships between the various classes and subclasses. There can also be Figure 4Relationships not shown in the figure. For example, behavior subclasses, traffic entity subclasses, environmental subclasses, and trigger subclasses can also be object properties of the story class.

[0045] Each class or subclass in the static test scenario ontology and the dynamic test scenario ontology can include object properties for connecting two classes and data properties for connecting concepts and data types (e.g., numbers, times, strings, etc.). For example, Table 1 lists the main object properties in the static test scenario ontology and the dynamic test scenario ontology. The object properties of the static test scenario ontology can be used to describe the relationships between the main concepts (e.g., roads, traffic units, surrounding objects, etc.) in the static test scenario ontology. For example, the road class can be connected to the lane class or subclass through the object property "hasLane". Similarly, the object properties of the dynamic test scenario ontology can be used to describe the relationships between the main concepts in the dynamic test scenario ontology. For example, the belonging environment object property can be used to describe which environment class or subclass the current class or subclass (e.g., weather) belongs to. These object properties can link dynamic scenarios (e.g., OpenSCENARIO) and static scenarios (OpenDRIVE).

[0046]

[0047]

[0048] Table 1

[0049] Table 2 lists the main data properties in the static test scenario ontology and the dynamic test scenario ontology. The data properties of the static test scenario ontology can be used to describe and explain the relationships between the main classes / subclasses and data types in the static test scenario ontology. For example, the lane class can be connected to the string data type used to describe the lane type (e.g., motor vehicle lane, non-motor vehicle lane, left-turn lane, right-turn lane, etc.) through the data property "hasLaneType". Similarly, the data properties of the dynamic test scenario ontology can be used to describe the relationships between the main classes / subclasses and data types in the dynamic test scenario ontology.

[0050]

[0051] Table 2

[0052] Although the above in combination with Figure 3 and Figure 4A specific example of the hierarchical structure of classes and subclasses of the static test scenario ontology and the dynamic test scenario ontology is described. The autonomous driving test scenario ontology can also have various other hierarchical structures. For example, the static test scenario ontology and the dynamic test scenario ontology can respectively have hierarchical structures consistent with those adopted by the OpenDRIVE and OpenSCENARIO standards. For details, reference can be made to the descriptions in the OpenDRIVE and OpenSCENARIO standard documents.

[0053] Return Figure 2 , in step 220, method 200 may include generating a specific test scenario ontology instance according to the autonomous driving test scenario ontology imported in step 210 and the specific test scenario requirements. The specific test scenario requirements may be a description of the specific scenario to be tested in natural language. For example, it may be a specific embodiment of various natural language description files given for the Figure 1 illustrated specific test scenario. The specific test scenario ontology instance can be described using the Web Ontology Language and stored as a file with the owl extension. Generating the specific test scenario ontology instance may be a process of instantiating various relevant classes and / or subclasses (i.e., the classes and / or subclasses involved in the specific test scenario) in the test scenario ontology according to the specific test scenario requirements. In an embodiment where the test scenario ontology includes a static test scenario ontology and a dynamic test scenario ontology, the static scenario test ontology and the dynamic test scenario ontology can be instantiated separately, and the static scenario test ontology instance can be imported or called during the instantiation of the dynamic test scenario ontology.

[0054] Generating the specific test scenario ontology instance in step 210 may further include determining the parameters for the specific test scenario according to the specific test scenario requirements. The parameters of the specific test scenario may be described in natural language in the specific test scenario description file. In one embodiment, according to the natural language description of the specific test scenario requirements Figure 1 illustrated, it can be determined that the road of the specific test scenario includes 1 intersection and connections in 4 directions of up, down, left, and right. Each connection includes two lanes. The initial speed of the bicycle is 20 km / h, the initial speed of the car is 80 km / h, the position where the car starts to decelerate is 50 m away from the intersection (coordinate conversion can be performed according to different coordinate systems, such as lane reference lines, etc.), the deceleration of the car is 3 m / s 2 , the speed of the car passing through the intersection is 30 km / h, the position where the car starts to accelerate is 10 m away from the intersection, and the acceleration of the car is 2 m / s 2 , and so on.

[0055] In another embodiment, only the value ranges of some parameters are described in the natural language description file of the specific test scenario requirements. For example, in the specific test scenario shown in Figure 1 , the speed range of the bicycle can be from 10 km / h to 25 km / h, the speed range of the car can be from 50 km / h to 90 km / h, the position where the car starts to decelerate can be more than 10 m away from the intersection, and so on. In this case, specific parameter values can be selected within the corresponding value ranges. For example, sampling can be performed within the corresponding value ranges according to an appropriate distribution to determine the parameters of the specific test scenario. In another embodiment, when the specific parameters of the required test scenario are not described in the natural language description file of the specific test scenario requirements, the parameters of the specific test scenario can be determined based on big data analysis (for example, real-world data of the traffic network based on a knowledge graph).

[0056] In the above embodiment, the method of the present disclosure can automatically select and determine the numerical values of various parameters of the specific test scenario through a computer program, so as to be able to generate a more reasonable and comprehensive specific test scenario, in order to improve the efficiency of autonomous driving testing and improve the reliability of the tested autonomous driving technology.

[0057] After determining multiple different parameters of the specific test scenario, the determined parameter values can be used to perform parameter generalization on relevant classes / subclasses in the autonomous driving test scenario ontology. For example, referring to the specific test scenario example shown in Figure 1 , multiple instances of lane subclasses can be generated according to the determined lane parameter data, and multiple instances of story classes can be generated according to different driving states of the car. Therefore, generating the specific test scenario ontology instance in step 210 can further include performing knowledge graph-based parameterization on the autonomous driving test scenario ontology using the determined parameters to generate a knowledge graph composed of multiple specific test scenario ontology instances.

[0058] Figures 5-6 shows a schematic diagram of the knowledge graph of the specific test scenario according to an embodiment of the present disclosure. Figure 5 shows the knowledge graph based on the static test scenario ontology for the specific test scenario as shown in Figure 1 . As shown in Figure 5 , this specific test scenario includes 1 road instance 510, which includes 1 intersection instance 515 and 4 connection instances 520, 530, 540, and 550. The connection instance 520 includes two lane instances 522 and 524, the connection instance 530 includes two lane instances 532 and 534, the connection instance 540 includes two lane instances 542 and 544, and the connection instance 550 includes two lane instances 552 and 554. Although Figure 5Not shown, each instance of this specific test scenario may also have other object attribute parameters and data attribute parameters that are the same or different in part. For example, each lane instance may include data attributes such as lane width.

[0059] Figure 6 Shows a knowledge graph based on a dynamic test scenario ontology for a specific test scenario as Figure 1 shown. As Figure 6 shown, this specific test scenario may include story instances 610, 640, 650, and 670 corresponding to an initial scenario, a scenario where a car decelerates approaching an intersection, a scenario where a car accelerates leaving an intersection, and a final scenario, respectively. The story instance 610 of the initial scenario may include an initial behavior instance 612. The initial behavior instance 612 may include a bicycle instance 602 and a car instance 604. The initial behavior instance 612 may also include a bicycle initial road setting instance 614, a bicycle initial speed setting instance 616, a bicycle initial position setting instance 618, a bicycle initial lane setting instance 620, a bicycle initial connection setting instance 622, a car initial lane setting instance 624, a car initial position setting instance 626, a car initial connection setting instance 628, a car initial road setting instance 630, and a car initial speed setting instance 632, etc. The story instance 640 of the approaching intersection scenario may include an approaching intersection trigger instance 642 (e.g., the distance to the intersection is less than a specific parameter threshold) and an approaching intersection behavior instance 644. The approaching intersection behavior instance 644 may include a bicycle instance 602 and a car instance 604. The approaching intersection behavior instance 644 may also include a car deceleration speed setting instance 646 and a bicycle speed setting instance 648. The story instance 650 of the leaving intersection scenario may include a leaving intersection trigger instance 652 (e.g., the distance to the intersection is greater than a specific parameter threshold) and a leaving intersection behavior instance 654. The leaving intersection behavior instance 654 may include a bicycle instance 602 and a car instance 604. The leaving intersection behavior instance 654 may also include a car lane setting instance 656, a car acceleration speed setting instance 658, a car connection setting instance 660, a bicycle lane setting instance 662, a bicycle connection setting instance 664, and a bicycle speed setting instance 666, etc. The story instance 670 of the final scenario may include a final trigger instance 672 (e.g., the car speed reaches a specific parameter threshold) and a final behavior instance 674. The final behavior instance 674 may include a bicycle instance 602 and a car instance 604. The final behavior instance 674 may also include a car position setting instance 676, a car final speed setting instance 678, a bicycle position setting instance 680, and a bicycle final speed setting instance 682, etc. Although Figure 6 not shown, each instance of this specific test scenario may also have other object attribute parameters and data attribute parameters that are the same or different in part.

[0060] The following shows a pseudo-code example of generating a knowledge graph of real-world data for a dynamic test scenario by performing knowledge-graph-based parameter generalization according to the dynamic test scenario ontology. A similar processing flow can be used to generate a knowledge graph of real-world data for a static test scenario. In the following pseudo-code, the OwlReady2 library is first imported. It is a tool library in the Python language for operating on OWL ontologies, including importing, modifying, and saving ontologies, etc.; MasterOntology.owl is a previously generated dynamic test scenario ontology file; Logical Knowledge Graph.owl is an output parameterized knowledge graph file using the OWL language, which can be directly generated using the functions provided in the OwlReady2 library.

[0061]

[0062] Return Figure 2 , in step 230, method 200 may include generating a specific test scenario file that conforms to the corresponding autonomous driving test scenario simulation standard according to the generated specific test scenario ontology instance (e.g., knowledge graph). Different autonomous driving test scenario simulation standards may use different hierarchical structures to describe test scenarios, use different languages, and store them in different file formats.

[0063] In the case where the hierarchical structure used by the autonomous driving test scenario ontology to describe test scenarios is different from the hierarchical structure used by the corresponding autonomous driving test scenario simulation standard to describe test scenarios, in step 230, method 200 may further include converting the hierarchical structure of the autonomous driving test scenario ontology to the hierarchical structure of the autonomous driving test scenario simulation standard. For example, in the dynamic test scenario ontology described in combination Figure 4 a story class is directly defined, and the story class includes behavior subclasses; in contrast, in the OpenSCENARIO standard, a storyboard class is defined, which may include a story class, and the behavior class is not a subclass of the story class. Therefore, during the process of assigning values or parameterizing the classes defined in the OpenSCENARIO standard, it is necessary to convert the hierarchical structure of the autonomous driving test scenario ontology instance.

[0064] After assigning values or parameterizing the classes / subclasses defined in the autonomous driving test scenario simulation standard, specific test scenario files that conform to the specified language and format can be generated according to the provisions of the autonomous driving test scenario simulation standard. For example, both the OpenDRIVE and OpenSCENARIO standards specify the use of Extensible Markup Language (XML) to describe test scenarios and store them as files with the.xodr and.xosc extension formats respectively. Therefore, in one embodiment, in step 230, the specific test scenario described using the Web Ontology Language can be converted into a specific test scenario file in a file format that conforms to the autonomous driving test scenario simulation standard described using Extensible Markup Language (e.g.,.xodr and / or.xosc).

[0065] The following shows a pseudo-code example for generating a specific test scenario description file (ConcreteScenario.xosc) that conforms to the OpenSCENARIO standard based on the dynamic test scenario ontology parameterized knowledge graph file (Concrete KG.owl). In this example, the functions provided in the OwlReady2 library can be used to generate a specific test scenario description file that conforms to the OpenSCENARIO standard. A similar processing flow can be used to generate a specific test scenario description file that conforms to the OpenDrive standard (e.g., ConcreteScenario.xodr).

[0066]

[0067] Figure 7 The block diagram of a device 700 for autonomous driving test simulation according to an embodiment of the present disclosure is shown. The device 700 may include a memory 710 and at least one processor 720. The processor 720 may be coupled to the memory 710 and configured to execute the method 200 described above with reference to Figure 2 The processor 720 may be a general-purpose processor or may also be implemented as a combination of computing devices, for example, a combination of a DSP and a microprocessor, multiple microprocessors, the combination of one or more microprocessors and a DSP core, or any other such configuration. The memory 710 may store input data (e.g., test scenario ontology file), output data (e.g., specific test scenario description file), data generated by the processor 720 (e.g., knowledge graph of specific test scenarios), and / or instructions executed by the processor 720.

[0068] The various operations described in connection with the present disclosure can be implemented in hardware, software executed by a processor, firmware, or any combination thereof. In one embodiment of the present disclosure, a computer program product for autonomous driving simulation testing may include instructions for performing the above reference Figure 2The processor of the described method 200 can execute computer code. In another embodiment of the present disclosure, a computer-readable medium can store computer program code for autonomous driving simulation testing. In another embodiment of the present disclosure, a computer program product for autonomous driving simulation testing includes computer program code executable by a processor. When executed by the processor, the above computer program code can cause the processor to execute the method 200 described above with reference to Figure 2 The described method 200. A computer-readable medium includes both a non-transitory computer storage medium and a communication medium, and the communication medium includes any medium that facilitates the transfer of a computer program from one place to another. Any connection can be appropriately referred to as a computer-readable medium. Other embodiments and implementations are within the scope of the present disclosure.

[0069] In addition to what is described herein, various modifications can be made to the disclosed embodiments and implementations of the present invention without departing from the scope thereof. Therefore, the description and examples herein should be construed as illustrative and not in a limiting sense. The scope of the present invention should be measured only by reference to the claims.

Claims

1. A method for autonomous driving simulation testing, comprising: Importing an autonomous driving test scenario ontology corresponding to the autonomous driving test scenario simulation standard; Generating a specific test scenario ontology instance according to the autonomous driving test scenario ontology and specific test scenario requirements; and Generating a specific test scenario file that conforms to the autonomous driving test scenario simulation standard according to the specific test scenario ontology instance.

2. The method according to claim 1, further comprising: Generating the autonomous driving test scenario ontology according to the autonomous driving test scenario simulation standard before importing the autonomous driving test scenario ontology.

3. The method according to claim 1, wherein The hierarchical structure of the autonomous driving test scenario ontology for describing the test scenario is different from the hierarchical structure of the autonomous driving test scenario simulation standard for describing the test scenario.

4. The method according to claim 1, wherein The hierarchical structure of the autonomous driving test scenario ontology for describing the test scenario is the same as the hierarchical structure of the autonomous driving test scenario simulation standard for describing the test scenario.

5. The method according to claim 1, wherein The hierarchical structure of the autonomous driving test scenario ontology includes multiple classes for describing concepts in the test scenario, one or more of the multiple classes include one or more subclasses, and the classes and subclasses include object properties for describing the relationships between other classes or subclasses and data properties for describing the relationships between the classes and subclasses and their data types.

6. The method according to claim 5, wherein The hierarchical structure of the autonomous driving test scenario ontology is adjustable based on test scenario requirements.

7. The method according to claim 1, wherein The generating of the specific test scenario ontology instance includes: Determining parameters for the specific test scenario according to the specific test scenario requirements; Parametrizing the autonomous driving test scenario ontology based on a knowledge graph using the parameters to generate a knowledge graph composed of multiple specific test scenario ontology instances.

8. The method according to claim 3, wherein The generating of the specific test scenario file that conforms to the autonomous driving test scenario simulation standard includes: Converting the hierarchical structure of the autonomous driving test scenario ontology into the hierarchical structure of the autonomous driving test scenario simulation standard.

9. The method according to claim 1, wherein, The autonomous driving test scenario ontology and the specific test scenario ontology instance are described using the Web Ontology Language, and the specific test scenario file is described using the Extensible Markup Language.

10. The method according to claim 9, wherein The generating of the specific test scenario file that conforms to the autonomous driving test scenario simulation standard includes: Converting the specific test scenario described using the Web Ontology Language into a specific test scenario file in a file format that conforms to the autonomous driving test scenario simulation standard and is described using the Extensible Markup Language.

11. The method according to claim 1, wherein, The autonomous driving test scenario simulation standard includes: a static test scenario simulation standard for describing static test scenarios, and a dynamic test scenario simulation standard for describing dynamic test scenarios; and wherein, the autonomous driving test scenario ontology includes: a static test scenario ontology corresponding to the static test scenario simulation standard, and a dynamic test scenario ontology corresponding to the dynamic test scenario simulation standard.

12. The method according to claim 11, wherein, The hierarchical structure of the static test scenario ontology includes a road class, a traffic unit class, and a surrounding object class, and among them, the road class includes a connection subclass and an intersection subclass.

13. The method according to claim 11, wherein The hierarchical structure of the dynamic test scenario ontology includes vehicle class, pedestrian class, story class, and environment class, and among them, the story class includes behavior subclass and trigger subclass.

14. An apparatus for autonomous driving simulation testing, comprising: a memory; and a processor coupled to the memory and configured to execute the method according to any one of claims 1-13.

15. A computer-readable medium storing computer program code for autonomous driving simulation testing, the computer program code, when executed by a processor, causing the processor to execute the method according to any one of claims 1-13.

16. A computer program product for autonomous driving simulation testing, including processor-executable computer program code for executing the method according to any one of claims 1-13.

Images