We recently presented the MR-CKR framework to reason with knowledge overriding across contexts organized in multi-relational hierarchies. Reasoning is realized via ASP with Algebraic Measures, allowing for flexible definitions of preferences. In this paper, we show how to apply our theoretical work to autonomous-vehicle scene data: we apply MR-CKR to the problem of generating challenging scenes for autonomous vehicle learning. In practice, most of the scene data for AV learning models common situations, thus it might be dificult to capture cases where a particular situation occurs (e.g. partial occlusions of a crossing pedestrian). The MR-CKR model allows for data organization exploiting the multi-dimensionality of such data (e.g., temporal and spatial dimension). Reasoning over multiple contexts enables the verification and configuration of scenes, using the combination of diferent scene ontologies. We describe a framework for semantically guided data generation, based on a combination of MR-CKR and algebraic measures. The framework is implemented in a proof-of-concept prototype exemplifying some cases of scene generation.
Testing and evaluation are important steps in the development and deployment of Automated Vehicles (AVs). To comprehensively evaluate the performance of AVs, it is crucial to test the AVs’ perception systems in safety-critical scenarios, which rarely happen in naturalistic driving environment, but still possible in practice. Therefore, the targeted and systematic generation of such corner cases becomes an important problem.
Most existing studies focus on generating adversarial examples for perception systems of
AVs which are concerned with very simple perturbations in the input (e.g., changing the
color or position of a vehicle). More in general, the generation of adversarial or challenging
examples for neural models is an important problem that gained interest both in industry1
and research [
On the other hand, limited eforts have been put on the symbolic generation of complex scenes:
this is the problem we want to consider in this paper, in particular aiming at an ontology-based
and context-specific scene generation (e.g., child walking a dog in the evening in rainy weather).
Specifically, we define our task of interest as follows: given an existing scene (represented by a
scene graph) from a known dataset, we want to generate a new set of scenes that are variations
of the current scene and are:
1. Realistic: consistent with the ontologies describing objects in the scene (e.g., trafic signs
usually do not move);
2. Interesting: they satisfy a semantic restriction, which tells us that the scene is for example,
“dangerous” or challenging for our prediction model (e.g., seeing a cat in the middle of the
street requires special action);
3. Similar: changing the original scene to the generated scenes requires only small variations.
We propose to use symbolic methods to generate valid and challenging scenes on the base
of existing scene graphs and semantic definitions of scenes. In particular, Multi-Relational
Contextualized Knowledge Bases (MR-CKRs) [
Additionally, we need a way to measure how similar the generated scenes are to the original
scene that we started from: Algebraic Measures [
Our main contributions can be summarized as follows: – We provide a novel framework for semantically guided data generation, which can be adversarial or training data. An overview of the framework is presented in Section 2. By basing our framework on a combination of MR-CKRs and Algebraic Measures we obtain a highly lfexible approach with eficient solving options by employing translations to ASP. – MR-CKRs allow us (i) to incorporate ontological background knowledge ensuring realism of the generated data and (ii) to contextualize the notion of what makes a generated input interesting. The MR-CKR formalism and its use are presented in Section 3.
MR-CKR
– Algebraic Measures enable the maximization of similarity between original and generated data.
The definition of similarity by Algebraic Measures and its realization via weak constraints is presented in Section 4. – We provide a proof of concept implementation of our framework in ASP. Our prototype (presented in Section 5) for scene generation in the domain of AV is intentionally kept minimal but shows promise.
Before we go into the technical details of how we generate descriptions of new challenging training scenes, we provide a general structural overview of our framework.
The architecture of our framework is described in Figure 1. The schema shows that we use an MR-CKR to define, on the one hand, the possible scene modifications and on the other hand diferent contexts, here 1 and 2, that specify possibilities for a scene to be challenging respectively interesting. Ideally, these diferent diagnoses correspond to insights of a neural network engineer for poor performance of the current neural network. For example, in the AV context, we might observe that a car does not stop in the correct location when there is not only a stop sign but also a stop line marking that specifies where the car should stop. Here, we would therefore want to modify scenes in such a manner that they have both a stop sign and a stop line marking.
In general, the goal is to generate more scenes that we suspect the network also performs badly on, such that we have adversarial examples that we can use to train the neural network in the hope of improving its performance on these situations that are presumably hard for it, due to a lack of training data. Given the diagnoses in diferent contexts that may be related via specialization or otherwise, we can then use the ASP translation of an MR-CKR to obtain an equivalent ASP encoding to compute models, i.e., representations of generated scenes that are realistic according to the base ontology included in the MR-CKR.
Moreover, we add further ASP constraints to ensure that the modifications of the scene make the resulting scene (a) challenging, i.e., it satisfies a diagnosis (using strong constraints) and (b) close to a given starting scene (using weak constraints that express the algebraic measure).
With such combination, we can thus obtain realistic, challenging scenes that are as similar to the starting scene as possible. On top of that, the diferent contexts allow us to specify diferent types of target diagnoses resulting in one generated scene that includes it per context.
In the following, we substantiate our abstract idea by formalizing how we generate scenes with MR-CKR and measure their similarity with Algebraic Measures.
We begin by briefly introducing the MR-CKR framework and then provide a solution for the scene generation task making use of MR-CKR.
We summarize in this subsection the main definitions of the MR-CKR formalism from [
We assume the customary definitions for description logics (see, e.g., [
The contextual structure of a MR-CKR is defined by a nonempty set N ⊆ NI of context names
and a set ℛ of one or more contextual relations ≺ over them, which are strict (partial) orders
≺ ⊆ N × N. A way to define contextual relations is to use contextual dimensions [
With each context of N, we associate a contextual language ℒΣ,N as an extension of ℒΣ representing its local language; in particular, axioms inside contexts can be specified as defeasible (i.e., they can be overridden in case of exceptions) with respect to one of the contextual relations composing the contextual structure. Formally, an r-defeasible axiom is any expression of the form D( ), where is an axiom of ℒΣ and ≺ ∈ ℛ. Multi-relational CKRs are then composed by a global structure of context based on the contextual relations in ℛ and a set of DL knowledge bases associated to each of the local contexts.
Definition 1 (multi-relational simple CKR). A multi-relational simple CKR (sCKR) over Σ and N is a structure K = ⟨C, KN⟩ where: (i). C is a structure (N, ≺ 1, . . . , ≺ ) where each ≺ is a contextual relation over N; (ii). KN = {Kc}c∈N for each context name c ∈ N, Kc is a DL knowledge base over ℒΣ,N.
Example 1. We provide a simple example of MR-CKR to better explain the intended use of defeasible axioms. Consider the sCKR K = ⟨C, {K1, K2}⟩ composed of the following elements:
C = K1 = {c2 ≺ c1}, {D(Dog ⊑ ¬DangerousAnimal )}, {Dog ⊑ DangerousAnimal , Dog (d )}.
Intuitively, we want to ensure that in the more specific context c2, dogs are viewed as dangerous animals, thus the more general defeasible axiom in c1 is not applied to the instance of Dog . Interpretations of MR-CKRs I = {ℐ(c)}c∈N are families of DL interpretations associated to each of the contexts that agree on the interpretation of individuals. Given an axiom ∈ ℒΣ with FO-translation ∀x. (x), we say that the instantiation of with a tuple e of individuals in NI, written (e), is the specialization of to e, i.e., (e), depending on the type of . Given a relation ⪰ , we denote with ⪰ − any other relation in ℛ diferent from ⪰ .
A clashing assumption for a context c and relation is a pair ⟨, e⟩ such that (e) is an axiom instantiation of , and c′ ⪰ − c′′ ≻ c. A clashing set for ⟨, e⟩ is a satisfiable set of ABox assertions s.t. ∪ { (e)} is unsatisfiable. Intuitively, clashing assumptions represent the assumption that e are exceptional individuals of , clashing sets provide a justification of such exceptionality. We extend interpretations with clashing assumptions in what we call CASinterpretations: a CAS-interpretation is a structure ICAS = ⟨I, ⟩ where I is an interpretation and = { 1, . . . , } such that each , for ∈ {1, . . . , }, maps every c ∈ N to a set (c) of clashing assumptions for context c and relation ≺ .
We say that a CAS-interpretation ICAS = ⟨I, ⟩ is a CAS-model for K (denoted ICAS |= K), if it verifies all strict and defeasible axioms of K, i.e., informally: (i) ℐ(c′) |= for every strict axiom in a context c with c′ ⪯ * c; (ii) ℐ(c′) |= for every -defeasible axiom D( ) in a context c related by a non- relation, that is c′ ⪯ − c; (iii) ℐ(c′′) |= (d) for every -defeasible axiom D( ) in a context c with c′′ ≺ c′ ⪯ − c and d not exceptional, that is ⟨, d⟩ ∈/ (c′′).
We say that ⟨, e⟩ ∈ (c) is justified for a CAS model ICAS , if some clashing set ⟨, e⟩,c exists such that ℐ′(c) |= , e⟩,c (and for all I′CAS agreeing on the interpretation of individuals).
⟨ A CAS model ICAS of a sCKR K is justified , if every ⟨, e⟩ ∈ is justified in K.
We provide a local preference on clashing assumption sets for each of the relations: (LP). 1 (c) > 2 (c), if for every ⟨ 1, e⟩ ∈ 1 (c) ∖ 2 (c) with D( 1) at a context c1 ⪰ − c1 ≻ c, some ⟨ 2, f ⟩ ∈ 2 (c) ∖ 1 (c) exists with D( 2) at context c2 ⪰ − c2 ≻ c s.t. c1 ≻ c2.
Intuitively, 1 (c) is preferred to 2 (c) if 1 (c) exchanges the “more costly” exceptions of 2 (c) at more specialized contexts with “cheaper” ones at more general contexts. A model preference is obtained by combining the preferences of the relations: it is a global lexicographical ordering on models where each ≺ defines the ordering at the -th position. (MP). I1CAS = ⟨I1, 11, . . . , 1⟩ is preferred to I2CAS = ⟨I2, 21, . . . , 2⟩ if: (i) there exists ∈ {1, . . . , } and some c ∈ N s.t. 1 (c) > 2 (c) and not 2 (c) > 1 (c), and for no context c′ ̸= c ∈ N it holds that 1 (c′) < 2 (c′) and not 2 (c′) < 1 (c′). (ii) for every < ∈ {1, . . . , }, it holds 1 ≈ 2 (i.e., (i) or its converse do not hold for ≺ ).
Finally, we say that an interpretation I is a CKR model of K (in symbols, I |= K) if: (i) K has
some justified CAS model ICAS ; (ii) there exists no justified I′CAS that is preferred to ICAS .
Example 2. Using the semantics mechanism from above, we can show how to interpret the
sCKR in the previous example. We can consider the CAS-interpretation ICAS = ⟨I, ⟩ where
(c2) = {⟨Dog ⊑ ¬DangerousAnimal , ⟩}. This implies that ICAS is a CAS-model if the
defeasible axiom of c1 is not applied to the only Dog in c2, as expected. Note that such CAS-model is also
justified, since the clashing assumption admits the clashing set {Dog (), DangerousAnimal ()}:
thus, considering that no other alternative CAS-model that is minimal with respect to the
preference can be defined, the considered interpretation is also a CKR-model. The preference
deifned above is useful to prefer defeasible axioms in the most specific contexts: for example, if
Dog ⊑ DangerousAnimal in c2 was defined as defeasible (w.r.t. the same contextual relation of
the above defeasible axiom), the context below c2 would have preferred the more specific axiom.
As a method to implement reasoning on MR-CKRs, we provided in [
For details and discussion, we refer to [
Following the intuitive structure of Figure 1, the role of MR-CKR in our architecture is to define the logical constraints of the scenes we want to generate, on the basis of a common scene ontology. Given its multi-contextual structure, the MR-CKR is useful to provide (i) a complex representation (a contextualization) of the contents of the base scene and (ii) its modifications towards the diferent diagnoses of interest.
With respect to the second aspect, the basic organization of contexts can be defined as in Figure 2. The contexts of this structure are related by a contextual relation ≻ , denoting the relation of similarity: the upper context Exchange contains, in form of -defeasible axioms, the axioms that can be modified in the diagnosis scenes. In the Base context, we assume to have the description of the base scene and the base axioms of the scene description ontology. The contexts Diagnosis-1 , . . . , Diagnosis-N then provide the diferent modifications to the base scene that we are interested in modeling. The kind of axioms that are needed to model the diferent modifications depend on the kind of changes (additions, deletions, etc.) that we want to admit in scene modifications; more details on such axioms will be provided in the following sections, where we consider specific modifications.
With respect to the scene contextualization, we can take advantage of the multi-relational nature of MR-CKR to further define the properties of the context in which the scene takes place.
Diagnosis-1
Diagnosis-N
Base City-exch
City-base General-d1
General-dN
City-d1
City-dN
Town-d1
Town-dN Example 3. An example of such contextualization is shown in Figure 3. In this contextual structure, the relation given by the horizontal arrows represents the specialization of scenes with respect to the specificity of the location: starting from axioms that are verified for general scenes, we can add further logical constraints that are true for city scenes and then town scenes. Note that such direction is orthogonal to the base contextual structure described above: location-defeasible axioms can express knowledge that is, e.g., accepted in general locations, but not valid in town scenes. After modelling scenes by such framework, we want to use the translation of MR-CKR to ASP in order to generate the possible models of the diagnoses contexts: these models then correspond to alternative generated scenes. However, we now need a method to provide a measure for the similarity of the generated scenes with respect to the scenes of interest: as we detail in the following sections, this can be easily defined by means of algebraic measures.
If we generate a new scene based on a starting scene, we want to optimize a measure of similarity.
Here, we use algebraic measures [
Definition 2 (Semiring). A commutative semiring = (, ⊕ , ⊗ , ⊕ , ⊗ ) is an algebraic structure with binary infix operations ⊕ , ⊗ such that 1. ⊕ and ⊗ are associative and commutative, 2. ⊗ right and left distributes over ⊕ , 3. ⊕ (resp. ⊗ ) is a neutral element for ⊕ (resp. ⊗ ), and 4. ⊕ annihilates , i.e., ∀ ∈ : ⊗ ⊕ = ⊕ = ⊕ ⊗ .
Examples of well-known commutative semirings are
– F = (F, +, · , 0, 1), where F ∈ {N, Z, Q, R}, the semiring over the numbers in F with addition
and multiplication,
– = ([
Another list of semirings, which is annotated with applications, can be found in [
In order to connect the quantitative aspects of semirings and the qualitative ones of logics
we use weighted logics [
Definition 3 (Weighted Logic). Let be a set of propositional variables and let ℛ = (, ⊕ , ⊗ , ⊕ , ⊗ ) be a semiring. A weighted (propositional) formula over ℛ is of the form given by the grammar ::= | | ¬ | + | * where ∈ and ∈ . The value J Kℛ(ℐ) of w.r.t. an interpretation ℐ ⊆ is defined as: JKℛ(ℐ) = JKℛ(ℐ) = ︂{ ⊕⊗ ︂{ ⊕
⊗ J¬Kℛ(ℐ) =
∈ ℐ otherwise.
∈ ℐ otherwise.
( ∈ ) ( ∈ ) J 1 + 2Kℛ(ℐ) = J 1Kℛ(ℐ)⊕ J 2Kℛ(ℐ)
J 1 * 2Kℛ(ℐ) = J 1Kℛ(ℐ)⊗ J 2Kℛ(ℐ).
Algebraic measures combine the qualitative language of ASP with the quantitative one of weighted logic.
Definition 4 (Algebraic Measure). An algebraic measure = ⟨Π, , ℛ⟩ consists of an answer set program Π, a weighted formula , and a semiring ℛ. Then, the weight of an answer set ℐ ∈ (Π) under is defined by (ℐ) =
J Kℛ(ℐ).
Intuitively, Π determines the solutions and assigns them weights. Algebraic measures ofer
further queries that aggregate the weights of (some) solutions [
We measure the similarity of two scenes as the minimum cost required to modify one scene to be equal to another one. There are many ways to modify a scene. For simplicity, we restrict ourselves to deletion of object from class and addition of object to class , denoted deletion(, ) and addition(, ), with fixed costs 2 cost() and cost() respectively. Advanced options would be class variation, displacement, or property variation.
We use the weighted formula Πclass ,individual (addition(, ) * cost() + ¬addition(, )) * Πclass ,individual (deletion(, ) * cost() + ¬deletion(, )) over the semiring ℛmin,+, which takes the minimum of diferent options and sums up the costs of atomic modifications in one option.
Example 4. For example, consider the interpretation
ℐ = {addition(RollingContainer , 1), deletion(Child , 2), deletion(Child , 3)}. Intuitively, this means that we add the object 1 to the concept RollingContainer and remove the objects 2 and 3 from the concept Child . Thus, we expect a cost of cost() + 2 · cost().
Since the interpretation ℐ contains addition(RollingContainer , 1) the first row of evaluates to cost() and the second row evaluates to cost()⊗ cost(). Since we use ℛmin,+ the operation ⊗ is + and we obtain cost() + 2 · cost() as the final cost, as expected.
While algebraic measures are a useful and highly general tool, to specify quantitative measures
for the answer sets of logic programs, most solvers for ASP currently do not support optimization
of the weight of an algebraic measure. However, algebraic measures over the semiring ℛmin,+
can be translated to weak constraints [
Since we intentionally kept the measure simple, it is suficient to use the weak constraints :∼ addition(, ).[cost(), , , ] :∼ deletion(, ).[cost(), , , ] which add a cost of cost() for each individual and concept such that we add to concept (and anologously for deletion). In general, this is not as simple since measures can specify complex algebraic expression, which is why we prefer the specifiation via measures.
We have implemented and tested our approach using an example from Autonomous Driving.3 Here, we reconstructed and slightly extended the base ontology from [14, 15].4 It features 2i.e., costs do not depend on the class or individual. 3https://github.com/raki123/MR-CKR 4https://github.com/boschresearch/ad_cskg
D( ⊑ ) D( ⊑ ) ( ⊓ ) ⊔ ⊑
D( ⊑ )
D( ⊑ ) ℎ ℎ
⊓ ⊑ ⊥ ⊓ ⊑ ⊥ :∼ instd(X, ,Context,"main"). [1,X, ,Context] :∼ instd(X, ,Context,"main"). [1,X, ,Context] diferent scenes, each annotated with the objects included in it. The included objects are annotated with information about them, such as their type. Furthermore, the ontology includes axioms that add knowledge about the relationship between diferent concepts in the ontology. Overall, the base ontology has more than 3 million axioms, concerning knowledge of 41 concepts, more than 100 scenes, and more than 50,000 objects.
We provide an overall sketch of the construction of the MR-CKR and its interplay with ASP constraints in Figure 4. We go over the diferent parts step by step.
MR-CKR Encoding. Here, we describe how scenes can be modified (annoted via solid black boxes in Figure 4). Namely, we state that every named object should either be added or not added (resp. deleted) to each modifiable concept. Additionally, we ensure that the modification takes efect by stating that a concept contains exactly those objects (i) which it originally contained before modification and that were not deleted, or (ii) that were added.
Apart from that, the MR-CKR contains the axioms from the base ontology and one context
for each diagnosis . We use the following diagnoses:
1. ℎ: the scene contains an object that is in the class ℎ. It is dangerous due to
unpredictable behaviour compared to other humans.
2. : the scene contains an object that is in the class but no object in
the class . It is dangerous due to unpredictable behaviour of the rolling container.
We then translate the resulting encoding to ASP using the CKRew software5 from [
To ensure similarity, we add weak constraints (annoted via the dashed gray box in Figure 4). This ensures that a penalty of 1 is added every time we add or delete an individual to . Note that the penalty is applied for every context.
The ASP translation of the MR-CKR and the additional constraints constitute the encoding of the problem in ASP. To obtain solutions, we then used a standard ASP solver, namely clingo [16]. Example 5. Assume our input scene contains four objects 1, . . . , 4 and Child (i2 ), Child (i3 ), Car (i4 ) hold. Due to the ontology axiom Child ⊑ Human, we could derive Human(i2 ) and Human(i3 ).
Thus, in context 2, where we need a rolling container but no human, we need to remove 2 and 3 from the Child concept and add an object to the RollingContainer concept. Thus, a potential modification (restricted to context 3) is represented by the interpretation ℐ = {instd(1, , 3, “”), instd(2, ℎ, 3“”), instd(3, ℎ, 3, “”)}.
As discussed in the previous example, it has cost cost() + 2 · cost(), which is 3 since we assign cost 1 to addition and deletion respectively.
As there is no modification of a lower cost, one of the possible generated scenes for 3 consists of (1), (4), i.e., it contains a rolling container 1, no humans, but a car 4.
On the other hand, in the context 1 we do not need to perform any modifications, since the original scene already contains a child.
The original MR-CKR to ASP translation is capable of handling highly complex relations between contexts and supports arbitrary defaults and flexible ontological background knowledge. However, this comes at the cost of an encoding in ASP that is not suitable for our purposes, using large scene graphs with many contexts and concepts.
To circumvent this, we specialized the encoding to our setting. Recall that the (defeasible) axioms of the MR-CKR (see Figure 4, annoted in green) tell us that we guess either the addition or the non-addition of any named individual to , as long as there is no other reason in the ontology that prevents both. As our base ontology is consistent, there can never be a reason in our ontology that prevents the non-addition. Hence the either-or really holds in our setting.
This allows us to use the following rules to encode the (defeasible) axioms above: instd(X, ,Con,"main") :- instd(X,"Named",Con,"main"), not instd(X, ,Con,"main"). instd(X, ,Con,"main") :- instd(X,"Named",Con,"main"), not instd(X, ,Con,"main").
Clearly, the same can be done for deletion and non-deletion.
This specialized translation for our setting leads to a significant performance improvement. While the original encoding only allows us to generate new scenes using tiny starting scenes, the improved strategy allows inference of the real world scenes from the ontology within seconds. 100 s cond 80 e isn 60 e itnm40 u r 20 0
1
We briefly investigate how large the instances that we can solve can become, while maintaining a low runtime. Here, we compare the original translation, denoted General, and the specialized one, denoted Specialized.
Secondly, we investigate how much the solving time depends on (i) the number of objects in the scene and (ii) the number of contexts. We vary (i) between 1 and 20 and (ii) between 1 and 5 on a randomly chosen example scene from the ontology.
Here, we use clingo [16] on the generated programs with input option “-t 3” to specify that three threads in parallel should be used to solve the problem. We apply a time limit of 120 seconds and assign runs that do not finish during this time a runtime of 120 seconds.
The results of our investigation are given in Figure 5. We see that even if only one context is used, the runtime after General grows quickly. While it still remains in a feasible range when using one context and up to 20 objects in the scene, the same cannot be said when more contexts are used. For five contexts, solving already becomes slow when ten or more objects are included in the scene. Additionally, the original scene has many more objects (more than 300), thus, this translation can only be employed to restricted examples, even if there is only one context.
On the other hand, for Specialized we see that the solving time is consistently far below one second, even when using all five contexts and 20 objects in the scene. Note here the diferent limits of the Y-axis, which we adapted to make the runtimes visible. Even using the full scene, which constitutes a realistic industry size example (including more than 300 objects) the solving time remains at around 0.67 seconds. We observed a similar efect in the grounding size, which went to around 80 thousand rules and did not finish with more than half a million rules already produced for the specialized and general encoding, respectively.
We see that while the original translation General is able to handle a broader range of MRCKRs, it pays of to use the specialized translation Specialized in our setting. With Specialized we can generate new scenes in subsecond times, even if the full scene (i.e., all its objects) and all contexts are used. This suggests that with Specialized we can also generate new inputs for more complex semantic conditions and base ontologies than the ones provided in our prototype, giving us interesting opportunities to extend our work in the future.
We have introduced a new framework to generate new interesting inputs for neural models based on existing ones, in particular the setting of scene generation for AV scene data. Notably, our framework does so based on symbolic reasoning methods. This allows us, on the one hand, to incorporate real world knowledge (in the form of contextual knowledge) that ensures that the generated inputs are realistic, and, on the other hand, to formulate a semantic criterion that should be satisfied by the new input. We saw that all components that we incorporated in our framework add their respective benefits: – MR-CKR allows us (i) to incorporate ontological knowledge easily and (ii) to perform diferent modifications in diferent contexts. – Algebraic Measures allow us to easily specify a cost value to optimize. – ASP, as a declarative backend programming language, allows us to perform reasoning/scene generation eficiently using standard solvers.
While we only considered a small example in our prototype, it successfully generates new scene descriptions. Furthermore, as it can be easily generalized to the generation of diferent types of scenes, it provides a proof of concept of our approach.
In future work, it will be interesting to extend this example with more complicated semantic descriptions of interesting scenes gathered by inspecting poor performing inputs for a prediction task with a neural model: in particular, it would be interesting to use more complex contextual structures to represent diferent variations of the scenes, but also use inputs performances to give a quantification of the more interesting cases to be generated. Another open challenge is to use the symbolic description of the new scene to generate images that can be fed to the neural model and assess how much training with these new examples improves the network performance.
Acknowledgments. We would like to thank Michael Pfeifer, Nicole Finnie, Grace Hua and Jan-Hendrik Metzen from Bosch Center for AI for interesting discussions on the topic of scene generation. This work was partially supported by the European Commission funded projects “Humane AI: Toward AI Systems That Augment and Empower Humans by Understanding Us, our Society and the World Around Us” (grant #820437) and “AI4EU: A European AI on Demand Platform and Ecosystem” (grant #825619), and the Austrian Science Fund (FWF) project W1255-N23. The support is gratefully acknowledged. Proceedings, volume 1265 of Lecture Notes in Computer Science, Springer, 1997, pp. 2–17.
URL: https://doi.org/10.1007/3-540-63255-7_2. doi:10.1007/3-540-63255-7∖_2. [14] S. N. Chowdhury, R. Wickramarachchi, M. H. Gad-Elrab, D. Stepanova, C. A. Henson, Towards leveraging commonsense knowledge for autonomous driving., in: ISWC (Posters/Demos/Industry), 2021. [15] R. Wickramarachchi, C. Henson, A. Sheth, Knowledge-infused learning for entity prediction in driving scenes, Frontiers in big Data (2021) 98. [16] M. Gebser, R. Kaminski, B. Kaufmann, T. Schaub, Clingo = ASP + control: Preliminary report, CoRR abs/1405.3694 (2014). URL: http://arxiv.org/abs/1405.3694. arXiv:1405.3694.