KAOS is one of the most widely used Goal-Oriented Requirements Engineering (GORE) methods. The goal model is the central element of KAOS, employed to represent the goals of a system in the form of a hierarchy, where higher-level goals are refined into lower-level ones. The process of constructing a KAOS goal model for a new application can present challenges, requiring significant time and efort. Existing approaches have tried to partially automate the construction of goal models, however, this largely remains a complex, manual task. In this paper, we propose leveraging domain knowledge in the form of a Knowledge Graph (KG), which can assist the application designer in creating goals that are inspired from this knowledge. To accomplish this, we leverage semantic similarity measurement and Natural Language Inference (NLI) to efectively extract triples from the KG that are relevant to a high-level goal formulated by the designer. The extracted triples are further processed through sentiment analysis and graph-to-text generation, before presented to the designer. Via step-by-step interaction with our solution, the designer can gradually refine their initial goals into a goal hierarchy. We demonstrate our approach by applying it to the design of a flood management system, based on a handcrafted domain KG.
Goal-Oriented Requirements Engineering (GORE) is a specific approach to requirements
engineering, which focuses on capturing and modeling the goals that stakeholders want to achieve with a
software system. Several goal-oriented modeling methods have been proposed [
Creating a KAOS goal model for a new application is a complex and challenging process, requiring a substantial investment of time and efort from the application designer. Complexity comes from both identifying the goals of the new system and organizing them into a goal model.
In the literature, a few approaches have proposed to generate automatically or semi-automatically a
goal model by extracting goals from a small text corpus. Güneş et al. [
In contrast to these approaches, our solution in this paper aims at ofering interactive assistance to
the application designer for gradually conceiving and refining their goal model. We provide inspiration
to the designer based on existing domain knowledge. In particular, we propose leveraging domain
knowledge in the form of a Knowledge Graph (KG). Several online open KGs, such as DBpedia [
To efectively exploit domain knowledge, we propose an approach for exploring a KG that relies on several Natural Language Processing (NLP) techniques based on pre-trained language models. Our graph exploration approach includes: • Measuring semantic textual similarity between a high-level goal formulated by the application designer and the triples1 of the KG in order to identify anchor triples inside the KG. Anchor triples and their neighbor triples denote KG areas that can most probably provide relevant information to the application designer. • Employing Natural Language Inference (NLI) to identify a textual entailment relation between the high-level goal and one or several combined triples. If such entailment holds, these triples can be used to refine this goal. In particular, we propose to use textual entailment to approximate the contribution relation between a goal and one of its subgoals in which this goal is refined: satisfaction of the subgoal contributes to satisfaction of the parent goal. • Using Sentiment Analysis to identify positive and negative connotations in triples. Triples with negative connotations describe facts that should be avoided. By stating explicitly this connotation, we improve entailment detection between such triples and a formulated goal. Additionally, based on this analysis, triples extracted from the KG are presented to the application designer with the qualification [ACHIEVE] or [AVOID], which can facilitate the creation of related goals. • Applying Graph-to-Text (G2T) generation to build grammatically correct, fluid and semantically coherent text from one or more triples extracted from the KG before presenting them to the application designer. G2T simplifies the comprehension of the entailed triples and facilitates the inspiration of new goals.
Based on these techniques and via step-by-step interaction with our solution, the designer can gradually refine their initial goals into a goal hierarchy that encompasses all the relevant information extracted from the KG. Certainly, this information can and should be complemented with information coming from other sources (inputs from stakeholders, designer’s expertise) to generate a complete goal model. To validate our approach, we demonstrate its functioning by applying it to the design of a lfood management system, based on our flood warning use case and domain KG. Besides inspecting the relevance of the generated goal model, we measure the amount of relevant information that was successfully extracted from the KG as well as the time-related performance of our solution.
The rest of the paper is structured as follows: Section 2 presents some background notions related to NLI and G2T generation. Section 3 introduces our method for building a KAOS goal model. Section 4 1A RDF triple, or a semantic triple, is a representation of data from a knowledge graph composed of a subject and an object nodes linked by a directed edge from the subject to the object called the predicate. presents the demonstration of our approach. Section 5 mentions some threats to the validity of the proposed approach. Section 6 discusses related works. Finally, in Section 7, we conclude and give directions for future work.
The code used in the production of this paper is available at https://github.com/ShahinAbdoulSoukour/ KG_for_goal_model_generation.
Natural Language Inference (NLI), also referred as Textual Entailment Recognition (TER), is a task aiming at labelling a pair of natural language texts, the premise and the hypothesis, based on the three following cases: the hypothesis can be deduced from the premise (entailment); the negation of the hypothesis can be deduced from the premise (contradiction); neither the hypothesis nor its negation can be deduced from the premise (neutral).
Multiple approaches have been proposed to tackle NLI tasks, but here we will only focus on the
use of language models trained specifically for this task. This approach is generally performed using
Transformers-based models, such as BERT [
Graph-to-Text generation (G2T) is a task aiming at rendering the entities in a graph and their relations
as a natural language text. The objective is generally to make the information stored in a KG readable
for non-specialist users. The most common criterion of evaluation of G2T models is the similarity of
the text generated with a reference description of the graph written by a human, using metrics such
as BLEU [
We elaborate in this section our method for assisting the application designer in building a KAOS goal model for a new application by relying on knowledge coming from a pre-existing domain KG. The designer launches the method (which takes the form of an interactive tool) by formulating an initial goal that characterizes the new application, typically a high-level one. After exploring the KG, the tool returns one or more pieces of text that analyze or refine the submitted goal. By using directly these texts or getting inspired from them, the designer can create one or more subgoals for the initial goal. Our approach comprises the following steps (see Figure 1).
1. Formulate a goal. The application designer formulates a goal. Ideally, this goal should be quite
abstract and not composite. A composite goal should be split into more elementary goals. This
allows more eficient exploration of the KG based on entailment. In particular, our experimentation
with the employed NLI model showed that in most cases an entailment is correctly identified when
the hypothesis is an abstraction of the premise.
2. Search for anchor triples in the KG. Based on the goal submitted by the application designer,
relevant triples are sought in the KG. Querying a KG in order to find elements of interest can be
tedious and time consuming. It requires knowledge of the query language (typically SPARQL) and
preferably some understanding of the concepts and structure of the KG. If the latter does not hold,
SPARQL queries return empty results and need to be reformulated. Even when trying keyword
search, a SPARQL query will not return any results, if an exact match is not found. Furthermore,
while the use of a visual representation can facilitate information retrieval for small-scale KGs, this
solution tends to be less efective at a larger scale. To tackle this issue, we use SBERT [ 24] to compute
the semantic textual similarity between each triple of the KG and the expressed goal. Using semantic
textual similarity rather than simpler methods like TF-IDF or BLEU [
To demonstrate the approach proposed in this paper, we apply it to the creation of a goal model for a lfood management system. We rely on the implementation of our method as a software tool (coded in Python in the form of a Jupyter notebook) as well as on a domain KG related to flood warning that
we have created to support our demonstration (see Figure 2). The KG is composed of 49 vertices and 54 edges describing the fundamentals of flood management – the potential causes of floods, how to detect them, the expected impacts of a flood on people and properties, and how to prevent or mitigate these impacts. We use a configuration of our tool with a confidence parameter = 0.85 for semantic similarity. We observed that the resulting threshold value limits the risk of identifying irrelevant triples as anchor triples while returning a high enough number of triples. We demonstrate the functioning of the tool from the point of view of a designer as follows: a. We produce an initial high-level goal as abstract as possible. In this example, the high-level goal is “Anticipate the impact of floods on people ”. b. The goal is given as an input to our tool, which returns a series of natural language texts created from entailing triples retrieved from the KG. c. Based on the output of the tool, we propose one or multiple texts to refine our initial goal. For demonstration purposes, we do not add any information in the goals outside of that returned by our tool. d. We repeat Steps b and c for each subgoal produced until the tool stops returning new information or the information returned does not allow us to refine a goal.
The resulting goal model is displayed in Figure 3. Our tool highlights a total of 19 triples, i.e., 35.2 % of the 54 triples contained in our graph. Out of these 19 triples, 14 of them (73.7 %) helped us refine the goal(s) they were associated with. Moreover, the two main groups of irrelevant triples – inheritance relationships of “Property damage” and descriptions of elements related to the “Dam” node – were not highlighted by our tool. We therefore consider that our tool did facilitate the generation of our goal model. However, certain groups of relevant triples – inheritance relationships of the “Communication channels” and “General public” entities – were not highlighted by our tool. This leads us to consider that addition of inference rules for inheritance relationships could help identifying the relevance of such triples7. Implementation of inference rules in our tool for common predicates (e.g., rdf:type, owl:sameAs) is part of our future work toward the facilitation of goal model generation using KGs.
To further characterize these results, we present the outputs produced by our tool in the diferent steps of our method (as described in Section 3) for the goal “Use flood warning system to predict flood using weather forecastings”. In Step 2 of our method, we search for anchor triples in the KG. We exclude the triples “Flood warning system Predicts Flood” and “Flood warning system Analyzes Forecasting” as they were used to create this goal.
We identify the following anchor triples: (i) Flood warning system Generates Alerts ( = 0.68) (ii) Flood warning system Recommends Evacuation of residents ( = 0.67) (iii) Sensors Detect Flood ( = 0.64) (iv) Weather prediction Anticipates Heavy rainfall ( = 0.60) (v) Weather forecasting system is a type of Weather prediction ( = 0.59) (vi) Weather forecasting system Generates Forecasting ( = 0.59) 7For example, in the context of this graph, the rule “IF subject predicate parent AND child rdf:type parent THEN subject predicate child” could help us produce a more complete graph. Steps 3 and 4 inform us that each of these anchor triples is non-entailing with respect to the goal. Consequently, we explore their neighbors to identify potentially relevant elements of context. This graph exploration performed in Steps 5 and 6 does not lead us to identify relevant context for triples (i) to (v). However, pairing triple (vi) with its neighbor “Flood warning system Predicts Flood” allows us to produce an entailing contextualized triple. In Step 7, using G2T generation, we transform triple (vi) and its relevant context into a natural language version: “[ACHIEVE] the flood warning system analyzes and forecasts weather”. A subgoal can then be generated by the designer (see Figure 4).
Finally, execution time is a key metric for our interactive tool. For the goal “Anticipate the impact of lfoods on people ”, our tool outputs the entailing triples in 7.68 seconds on average. Additionally, text generation from these triples is performed in 2.49 seconds per text on average. These results are based on 5 executions of our code using an Nvidia 3080 RTX GPU with 32 GB RAM.
For validating our approach, we produced our own KG. While we consider that our graph accurately represents the topic that we tackled as an example – flood prevention and mitigation at the scale of city –, we should acknowledge that it has been produced in the context of our research and therefore may lack certain elements which could have been included by specialists of the domain. Our approach leverages the information stored in a KG and therefore the quality of the texts produced and consequently of the resulting goal model relies highly on the correctness and completeness of the KG.
On a diferent note, the complexity of our approach is linear with the number of triples in the graph. While this is perfectly acceptable for relatively small graphs, it is not possible to use our tool as it is currently implemented on open KGs such as DBpedia or private KGs containing thousands of triples without greatly increasing the execution time. Consequently, we need to limit the number of triples analyzed in our approach for large KGs, for example by using a subgraph containing only the nodes within a certain distance from an entity representing a key concept for the goal model to create.
Generating a goal model in an automatic or semi-automatic manner is a challenging task, and various
approaches have addressed this issue. Typically, these approaches apply NLP techniques on diferent
text sources (e.g., user stories [
Güneş et al. [
Casagrande et al. [
model. However, other sentences that may contain pertinent domain-specific information for creating a goal are not taken into account. Certain goals may be missed in the resulting goal model.
Shimada et al. [25] proposed a systematic approach to generate a goal model from user reviews of
an application. The authors use a hierarchical clustering method, which couples the clusters by order
of distance between them and organizes them in a tree structure (reviews clustering). Clusters are
interpreted as goals in the goal model. In the next step, each cluster is labeled with a goal description. In
particular, words in a cluster are weighted and several words that characterize the reviews in the cluster
are selected as a goal description. Similarly to Güneş et al. [
Nakagawa et al. [26] proposed a method to extract goals from requirements documents and to generate a goal model in a semi-automatic way. An analyst needs to answer a flow of questions (pre-defined) based on the requirement documents, which are asked interactively by the tool developed by the authors. The goal model is constructed based on the answers. The tool decides the location of goals in the goal model. This structuring of the goal model can be interesting. However, the goals need to be already provided in requirements documents.
Watanabe et al. [27] presented an open-source editing tool for automatically generating an initial KAOS goal model from a requirements description. The automatic construction of a goal model consists of 3 steps: parsing sentences into words, extraction of important sentences identified based on specific keywords, and extraction and linking goals based on word-to-word dependencies.
Research has also aimed at completing an existing goal model. Shibaoka et al. [28] used a domain ontology as domain knowledge in order to identify missing goals. The approach maps certain elements of the goal model in-progress onto the domain ontology. After that, the ontology inference mechanism deduces related ontological concepts that should possibly be added to the goal model. The suggested concepts are then added to the goal model by the requirement analyst. The goal model is thus enriched with new subgoals. However, this approach cannot be used for building an entire new goal model.
Compared to these diferent approaches, we propose an interactive method that assists the application designer at every stage of producing a goal model. In addition, while most works rely on requirements documents to build a goal model, our approach efectively exploits knowledge from a domain KG for suggesting or inspiring goals.
This research focuses on the generation of goal models using domain-specific KGs. The creation of goal models can be facilitated by highlighting relevant elements of knowledge from the KGs to refine high-level goals. We first propose a method for identifying relevant triples in order to refine a given high-level goal by leveraging NLI and sentiment analysis. Then, we demonstrate our method on a particular use case using a KG that describes the fundamentals of flood management. Our demonstration shows that our tool highlights pertinent elements of knowledge to help designers produce goal models. However, a more systematic evaluation of the approach is needed. Therefore, we propose to perform an empirical evaluation comparing the goal models produced using our method as well as other tools.
Toward the elaboration of a framework for assisted goal model creation using KGs, we propose several leads for future work. First, the identification of triples referenced in a goal is currently done by the designer. This work could be automated using factual faithfulness evaluation models such as FactSpotter [18] to assess the presence of certain triples in the goal’s text. Second, we propose to implement inference rules in our tool to improve the understanding of semantic relationships in the graph rather than relying only on the analysis of natural language transcriptions of the triples. Third, we aim at improving the scalability of our tool with regard to the number of triples in the graph to allow its use on open KGs in contexts where no domain-specific KG is available. This future work would need the automated creation of subgraphs from open KGs to identify only relevant information for the domain of the goal model. linari, Data-QuestEval: A Reference-less Metric for Data-to-Text Semantic Evaluation, in: 2021 Conference on Empirical Methods in Natural Language Processing (EMNLP), Association for Computational Linguistics, Punta Cana, Dominican Republic, 2021, pp. 8029–8036. URL: https://hal.sorbonne-universite.fr/hal-03479905. doi:10.18653/v1/2021.emnlp-main.633. [18] K. Zhang, O. Balalau, I. Manolescu, FactSpotter: Evaluating the Factual Faithfulness of Graphto-Text Generation, in: Findings of EMNLP 2023 - Conference on Empirical Methods in Natural Language Processing, Singapore, Singapore, 2023. URL: https://hal.science/hal-04257838. [19] P. Ke, H. Ji, Y. Ran, X. Cui, L. Wang, L. Song, X. Zhu, M. Huang, JointGT: Graph-text joint representation learning for text generation from knowledge graphs, in: Findings of the Association for Computational Linguistics: ACL-IJCNLP 2021, Association for Computational Linguistics, Online, 2021, pp. 2526–2538. doi:10.18653/v1/2021.findings-acl.223. [20] L. F. R. Ribeiro, M. Schmitt, H. Schütze, I. Gurevych, Investigating pretrained language models for graph-to-text generation, in: Proceedings of the 3rd Workshop on Natural Language Processing for Conversational AI, Association for Computational Linguistics, Online, 2021, pp. 211–227. URL: https://aclanthology.org/2021.nlp4convai-1.20. doi:10.18653/v1/2021.nlp4convai-1.20. [21] L. Nan, D. Radev, R. Zhang, A. Rau, A. Sivaprasad, C. Hsieh, X. Tang, A. Vyas, N. Verma, P. Krishna, Y. Liu, N. Irwanto, J. Pan, F. Rahman, A. Zaidi, M. Mutuma, Y. Tarabar, A. Gupta, T. Yu, Y. C. Tan, X. V. Lin, C. Xiong, R. Socher, N. F. Rajani, DART: Open-domain structured data record to text generation, in: Proceedings of the 2021 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Association for Computational Linguistics, 2021, pp. 432–447. doi:10.18653/v1/2021.naacl-main.37. [22] T. Castro Ferreira, C. Gardent, N. Ilinykh, C. van der Lee, S. Mille, D. Moussallem, A. Shimorina, The 2020 bilingual, bi-directional WebNLG+ shared task: Overview and evaluation results (WebNLG+ 2020), in: Proceedings of the 3rd International Workshop on Natural Language Generation from the Semantic Web (WebNLG+), Association for Computational Linguistics, Dublin, Ireland (Virtual), 2020, pp. 55–76. URL: https://aclanthology.org/2020.webnlg-1.7. [23] C. Rafel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y. Zhou, W. Li, P. J. Liu, Exploring the limits of transfer learning with a unified text-to-text transformer, Journal of Machine Learning Research 21 (2020) 1–67. URL: http://jmlr.org/papers/v21/20-074.html. [24] N. Reimers, I. Gurevych, Sentence-bert: Sentence embeddings using siamese bert-networks, in: Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing, Association for Computational Linguistics, 2019. URL: https://arxiv.org/abs/1908.10084. [25] H. Shimada, H. Nakagawa, T. Tsuchiya, Goal model construction based on user review classification, in: REFSQ Workshops, 2019. URL: https://api.semanticscholar.org/CorpusID:186206199. [26] H. Nakagawa, H. Shimada, T. Tsuchiya, Interactive goal model construction based on a flow of questions, IEICE Trans. Inf. Syst. 103-D (2018) 1309–1318. URL: https://api.semanticscholar.org/ CorpusID:145941947. [27] K. Watanabe, H. Nakagawa, T. Tsuchiya, Kaos modeling editor: A tool for semi-automated goal modeling (2023). [28] M. Shibaoka, H. Kaiya, M. Saeki, Goore : Goal-oriented and ontology driven requirements elicitation method, in: Advances in Conceptual Modeling – Foundations and Applications, Springer Berlin Heidelberg, Berlin, Heidelberg, 2007, pp. 225–234. doi:10.1007/978-3-540-76292-8_28.