Gradual argumentation frameworks represent arguments and their relationships in a weighted graph. Their mechanics are closely related to neural networks, which are considered as black-box models due to their dense structure with millions of neurons. Recent work tried making them human-understandable by trying to learn parameters that can be well approximated by decision trees. However, the tree remains just an approximation, which leaves the question how faithful it really captures the actual mechanics of the neural network. To circumvent the problem, structure learning ideas can be tailored to the discrete structure of gradual argumentation frameworks to learn sparse neural networks that can be directly interpreted as gradual argumentation frameworks. We discuss the learning problem, sketch a genetic and a particle swarm optimization algorithm to solve the problem and show first results on data sets from the UCI machine learning repository.
As black-box neural networks are increasingly applied in intelligent systems, questions about
their fairness, reliability and safety become louder. Various proposals have been made to make
their mechanics more transparent. This includes model-agnostic approaches [
As it turns out, there is a family of argumentation frameworks that can faithfully capture the
mechanics of multilayer perceptrons (MLPs). This the family of gradual abstract argumentation
frameworks (GAFs) that has been studied extensively in recent years [
1. How does learning GAFs difer from learning neural networks? The short answer is that learning GAFs is a special case of learning neural networks. However, this does not mean that we could simply apply existing algorithms. This is because we have to take account of the special structure that characterizes the special case. We explain the main diferences in more detail in the next three paragraphs. In short, when learning GAFs, we can apply standard algorithms for learning the parameters of a fixed network structure, but need specialized algorithms for structure learning (exploring the space of GAF structures).
Let us first note that the mainstream research in learning neural networks does not consider structure learning at all because of its computational complexity. The major architectures are based on a fixed and often densely connected graphical structure [ 15]. The user can typically define hyperparameters like the number of nodes per layer, but the nodes are always connected in a uniform way (e.g., fully connected dense layers or convolutional layers defined by kernels).
Learning sparse neural networks has become a more active area in recent years, but existing work does not focus on learning an interpretable network, but on decreasing the risk for overfitting, the memory and runtime complexity and the associated power consumption. Ideas include regularization to encourage neurons with weight 0 that can be deleted [16], pruning of edges [17], compression [18] and low rank approximation [19]. The idea is usually to make the network as small as possible (secondary goal), while keeping the performance high (primary goal). For us, the priorities are reversed: we want to achieve good learning performance (secondary goal) while keeping the network structure comprehensible (primary goal). We therefore focus on the structure learning problem, where we try to find the best performing structure in a space of interpretable network structures.
The argumentation view results in another model bias that difers from learning neural networks. The input for neural networks is typically numerical and discrete features have to be vectorized by one-hot-encoding or embedding functions. For us, the picture is again reversed. Our natural inputs are discrete arguments. While discrete features can naturally be represented by arguments, numerical features have to be discretized as we explain in more detail later. 2. Are the learnt GAFs really argumentation frameworks?
As GAFs have been studied extensively in the community, we assume that the reader accepts that they are argumentation frameworks. However, as we focus on learning acyclic GAF structures, one may criticize that acyclic graphical structures are not particularly interesting from an argumentation perspective. While this is true from a reasoning perspective, our position is that there is no need to consider more complicated structures if the acyclic structure already solves the problem. In particular, this simplicity should not be seen as a bug, but as a feature because it allows evaluating the argumentation graph in linear time, which is highly desirable when applying the learnt GAFs. Let us note that many applications of argumentation like the analysis of online discussions or online reviews naturally result in acyclic graphs [20, 21, 22]. Artificially introducing complexity will make the solution less comprehensible and computationally more demanding. We acknowledge that more structure may be necessary to solve more complicated problems, but we demonstrate that the structure that we consider here already sufices to solve many interesting problems.
Overview: We explain the necessary basics of gradual argumentation frameworks in the next section. In Section 3, we discuss the learning problem in more detail and sketch a genetic and a particle swarm optimization algorithm for structure learning. Section 4 shows first experimental results and some examples of learnt GAFs.
We consider gradual argumentation frameworks (GAFs) represented as graphs. Nodes represent arguments and edges represent attack and support relationships. Here, an argument is just an abstract entity that can be accepted to a certain degree based on the state of its attackers and supporters. Every argument is associated with a base score that can be seen as its apriori strength when ignoring its attackers and supporters. We consider edge-weighted GAFs similar to [12].
Definition 1 (Gradual Argumentation Framework (GAF)). A GAF is a tuple (, , , ) that
consists of
• a set of arguments and a set of edges ⊆ × between the arguments,
• a function : → [
Edges with negative weights are called attack and edges with positive weights are called support edges and denoted by Att and Sup, respectively.
Figure 1 shows on the left the graphical structure of a GAF that formalizes a simple decision problem. We assume that we want to decide if we should buy or sell stocks of a company and that we consider three arguments put forward by diferent experts. Attack relationships are denoted by solid and support relationships by dashed edges. We can define the semantics of GAFs by interpretations that assign a strength value to every argument.
Definition 2 (GAF interpretation). Let = (, , , ) be a GAF. An interpretation of is a
function : → [
Interpretations are often defined by an iterative procedure that initializes the strength values of arguments with their base scores and repeatedly updates the values based on the strength of their attackers and supporters. Interpretations are partial when the procedure fails to converge, which can happen in cyclic graphs [12]. However, we will only consider acyclic graphs here and all interpretations are guaranteed to be fully defined [ 13]. The strength update of an argument can often be divided into two main steps [12]: first, an aggregation function aggregates the strength values of attackers and supporters. Then, an influence function adapts the base score based on the aggregate as illustrated in Figure 1 in the middle. Examples of aggregation functions include product [8, 9], addition [23, 11] and maximum [12] and the influence function is defined accordingly to guarantee that strength values fall in the desired range.
We will only look at the MLP-based semantics from [14] here. Under this semantics, layered acyclic GAFs correspond to multilayer perceptrons (MLPs) with logistic activation functions and vice versa. This connection can be preserved for other activation functions of the MLP by changing the influence function of the GAF. However, bounded activation functions like the logistic function are most intuitive because they always result in finite strength values. The strength values of arguments are computed by the following iterative procedure: For every argument ∈ , we let (0) := () be the initial strength value. The strength values are then updated by doing the following two steps repeatedly for all ∈ (we use an auxiliary variable that carries the aggregate at iteration ):
(+1) := ∑︀(,)∈ (, ) · ().
Aggregation: We let Influence: We let (+1) := (︀ ln( 1− (()) ) + (+1))︀ , where () = 1+ex1p(− ) is the logistic function.
Figure 1 shows on the right how the MLP-based strength values of our running example evolve. The weight of all attack (support) edges was set to − 1 (1) and the base scores correspond to the strength values (y-axis) at iteration 0 (x-axis).
As shown in [14], the MLP-based semantics satisfies almost all semantical properties from the literature perfectly. A comparison to the earlier semantics DF-QuAD [9], Euler-based semantics [23] and the quadratic energy model [11] are shown in Figure 2. Only the Open-Mindedness property can be violated, and this can only happen when arguments have base scores 0 or 1. This case can actually not occur in our setting because base scores 0 or 1 correspond to infinite weights of the corresponding MLP that cannot be taken in practice. Roughly speaking,
Open-Mindedness demands that continuously adding attackers/supporters to an argument will eventually bring the strength to 0/1 [24]. For readers familiar with some, but not all of the properties, let us note that Open-Mindedness is similar to some "monotonicity"-properties that demand that an attacker/supporter must decrease/increase the strength of an argument. However, these properties are not suficient to guarantee that the strength converges to 0/1 in the limit. For example, the Euler-based semantics from [23] satisfies these monotonicity properties in most cases, but the lower limit is not 0, but ()2 (base score squared) [24]. The diferent semantics shown in Table 2 can be compared experimentally with the Java library Attractor1 [25].
Our goal is to learn an interpretable MLP/GAF that can solve classification problems with
suficient accuracy. The abstract goal of classification is to map inputs x to outputs . A typical
example is classifying a customer as credit-worthy or not (output) based on personal data like
age and income (input). The inputs are feature tuples x = (1, . . . , ), where the i-th value
is taken from some domain . The output is taken from a finite set of class labels . A
classification problem = ((1, . . . , ), , ) consists of the domains, the class labels and a
set of training examples = {(x, ) | 1 ≤ ≤ }.
a nAumnuermicearlicvaalluclea.sAsinfierimis paofrutnancttiospnecia:l c(︀a×se=is1apr)︀o× babil→istiRcctlhaastsiafiesrsign:s (︀ to× ev=e1ryp)︀ai× r (x, →)
[
As we explained in the previous section, MLPs can be seen as special cases of GAFs [14]. Hence, when we train an MLP, the resulting network can be understood as a classification GAF that is defined as follows.
Definition 3 (Classification GAF [ 26]). A Classification GAF with layers for a classification problem = ((1, . . . , ), , ) is a GAF (, , , ) such that = ⋃︀+1 =0 ⟨⟩ consists of the input arguments ⟨0⟩ = in and output arguments ⟨+1⟩ = out for and additional layers of arguments ⟨⟩ such that ⟨⟩ ∩ ⟨⟩ = ∅ for ̸= . Furthermore, ⊆ ⋃︀=0 ⋃︀=+1+1 ︀( ⟨⟩ × ⟨⟩︀) , that is, edges can only be directed towards deeper layers.
Classification GAFs under MLP-based semantics are always MLPs. However, while MLPs are usually dense and use continuous inputs, we want to learn sparse and well interpretable network structures with binarized inputs that can be understood as (propositonal) abstract arguments.
Given the graphical structure of a classification GAF , we can train the weights using the usual backpropagation procedure for neural networks. However, we also need a way to identify good candidates in the space of all structures. As we are interested in learning sparse networks, we will restrict the depth (number of layers), width (number of arguments per layer) and outdegree (number of outgoing edges from an argument) of the network.
Our hypothesis space ℋ is a set of graphical candidate structures. Here, the candidates are classification GAFs and we define the space by fixing a set of arguments = ⋃︀=+01 ⟨⟩ that can occur in GAFs. The hypothesis space ℋ(, ) then consists of all possible subgraphs of the fully connected GAF over with at most outgoing edges per argument, where subgraphs are defined by removing nodes from ∖ ⟨+1⟩ (only the output arguments are fixed) and removing arbitrary edges. Even though the depth , the size of the layers ⟨⟩ and the outdgree can be chosen arbitrarily, they should be kept small in order to find an easily interpretable GAF.
The candidate input arguments ⟨0⟩ can be created automatically from a given dataset . For every boolean feature , we introduce a corresponding argument . For every categorical feature with domain {1, . . . , }, we introduce arguments =1 , . . . , = . For every continuous feature with domain [, ] we can partition [, ] into bins 1, . . . , and introduce input arguments =1 , . . . , = . The bins can be created using statistics like quantiles as bin boundaries or using values that actually occur in .
In order to evaluate candidates, we consider a scoring function : ℋ → [
mutate(offspring)
population ← replace(pop, offspring)
until termination condition reached
return best(pop)
:
pop ← initialize(N)
do
evaluate(pop)
move_particle(pop)
until termination condition reached
return best(pop)
to (that is, the GAF that contains the same arguments like in the same layers and connects
every argument to every argument in the next layer). The hyperparameter ∈ [
Formally, our structure learning problem corresponds to the following optimization problem: ifnd a candidate * ∈ ℋ such that * = arg max ().
∈ℋ (2) Let us note that ℋ is exponentially large even if we fix the nodes in the network. To see this, assume that we consider nodes and allow only 2 edges per node. Then every node can have 1 or 0 outgoing edges, which results in 2 possible structures. Therefore, we will not attempt to ifnd an optimal solution * , but consider meta-heuristics in order to find a good solution.
The first meta-heuristic that we consider is a genetic algorithm. Genetic algorithms maintain a set of candidate solutions from ℋ during the search process. The candidate solutions ∈ are called chromosomes and the set the population. Given the hypothesis space ℋ(, ) over = ⋃︀+1 =0 |⟨⟩| · | ⟨+1⟩|. The entries =0 ⟨⟩, a chromosome is given by a vector of length ∑︀ can be 0 or 1 and indicate which neuron in layer is connected to which neuron in layer + 1. When creating the GAF from the chromosome representation, we only consider neurons that are either output neurons or have at least one outgoing edge.
Figure 3 shows on the left the template of our genetic algorithm. To begin with, a subset of the population (mating pool) is selected for reproduction based on their fitness defined by our scoring function . The ofspring is created by applying a recombination function that creates a new chromosome by combining features of the parent chromosomes. The reproduction step is followed by a mutation step that is supposed to move to interesting new regions of the search space, e.g., by randomly perturbing chromosomes. Finally, a replacement function replaces part of the current population with promising ofspring. The algorithm continues until a termination criterion is met. For details about the individual steps, we refer to the technical report [27]. The implementation is available at
https://github.com/jspieler/QBAF-Learning.
The second meta-heuristic that we consider is particle swarm optimization. Figure 3 shows on the right the template of our particle swarm optimization algorithm. Similar to genetic algorithms, we maintain a population of individuals (the swarm). Individuals are represented by vectors and we apply the same encoding like in our genetic algorithm. In every iteration, the algorithm evaluates all individuals and stores the globally best found solution and, for every individual, the individual best found solution. Each particle is then moved in a randomized direction that depends on the previous direction (initialized randomly), the location of the globally best solution found and the individual best solution found. For details about the individual steps, we refer to the thesis [28]. The implementation is available at
To illustrate our approach, we show some examples of learnt GAFs and compare them to other interpretable models.
Data sets: We used three diferent data sets from the UCI Machine Learning Repository 2, namely the Iris (4 numerical features, 150 instances), the Mushroom (22 categorical features, 8,124 instances) and the Adult Income (14 mixed features, 48,842 instances) data sets.
Baselines: We compared our two meta-heuristics for learning GAFs to two other interpretable classification models, namely logistic regression and decision trees with diferent depths.
Hypothesis space: The input arguments were generated using default discretization methods from the scikit-learn library. We allowed one hidden layer and experimented with diferent numbers of arguments and outgoing edges. We kept both numbers below 20 to find an easily interpretable GAF.
Results: We split the datasets into training and test set (80/20 %). To take account of randomness during training, we averaged the test results over 10 runs. For our baselines, decision trees worked generally better than logistic regression. Overall, the performance of GAFs is similar to decision trees. The interpretability is similar as well. However, we feel that the flat GAFs (one hidden layer) that we learnt can be easier to interpret than deeper decision trees as we explain later. We show some learning statistics in Table 1. More details about the experiments can be found in the technical report [27] (baselines and genetic algorithm) and the thesis [28] (particle swarm optimization).
Examples: We close the section with three hand-picked examples of sparse GAFs that have been created in the experiments in Table 1. More examples can be found in the technical report [27] (genetic algorithm) and the thesis [28] (particle swarm optimization or can be generated with the corresponding code. Figures 4, 5 and 6 show one of the 10 GAFs learnt for the Iris, Mushroom and Adult dataset, respectively. The picked examples are sparser than the mean in Table 1. Notably, the examples for the Mushroom and Adult dataset even have a better test accuracy than the mean in Table 1. This can be explained by the fact that sparser models are less prone to overfit the data because they have fewer parameters.
When interpreting multiclass classification problems like the Iris dataset, one has to keep in mind that a softmax function is applied on top. That is, when the strength values for the classes virginica, versicolor and setosa are , , , they are normalized to , , , where = + + . Hence, when is large, it will make and smaller. Hence, the class arguments can actually be seen as mutual attackers. In future versions, we may take account of this in the plotted graphs by printing special attack edges between them.
The GAFs should be interpreted recursively starting from the classes. For example, when interpreting the GAF for the Mushroom dataset in Figure 5, poisonous is supported by the upper hidden node. If it did not have any predecessors, the strength of its support would basically be given by its base score. However, it is rather strongly attacked by both odor_n and odor_l. Since both of them attack a supporter, they can be seen as indirect attackers of poisonous. However, the intermediate hidden node is necessary to capture their joint efect (remember that their efects are combined by the non-linear logistic function). The path from odor_a to poisonous can be interpreted similarly. In this case, the path can actually be simplified in a post-processing step to replace the supported attack with a simple attack. This is a simple, but useful improvement for the next version.
We discussed the problem of learning classification GAFs from data. While the parameter learning problem can be solved using standard methods for neural networks, we focus on the structure learning problem to learn easily interpretable GAFs. As opposed to regularization and pruning techniques that are commonly used for learning sparse neural networks, the structure learning problem allows restricting the space of possible structures, e.g., by defining upper bounds for the maximum number of outgoing edges per argument.
Our meta-heuristics learnt classification GAFs that are competitive with other interpretable models like logistic regression and decision trees. The main shortcoming of logistic regression is that it can only distinguish linearly separable classes. In contrast, as our GAFs are MLPs, the universal approximation theorem for MLPs implies that classification GAFs can approximate every function with a single hidden layer that is suficiently large. Decision trees are both expressive and well interpretable. However, as the trees grow, it becomes increasingly dificult to understand the various case diferentiations. The quantitative semantics of GAFs sometimes allows capturing the relationships in the data more succinctly. For example, while a decision tree with depth 7 achieved almost perfect test accuracy in our experiments, such a deep tree is already dificult to comprehend. The GAF in Figure 5 performed slightly worse, but is significantly easier to understand.
We are planning several improvements. We will add a postprocessing step that replaces paths between single arguments like in Figure 4 and the bottom path in Figure 5 with a single attack/support edge by merging the base scores and edge weights along the path appropriately. An interesting structural improvement is to replace interval arguments as ∈ [5.1, 6.9] in Figure 4 with fuzzy arguments like ∼ 6 that are not simply 0 or 1, but can increase/decrease gradually based on the degree to which they are satisfied. Another interesting structural improvement is to consider joint attacks/supports that could capture joint efects of arguments as in the upper path in Figure 5 without using hidden layers to make the GAF more interpretable.
Finally, let us note that [29] recently considered a similar problem of learning classical classification argumentation frameworks. As the structure learning problems in both settings are very similar, we will look at possible cross-fertilization in future work. [8] P. Baroni, M. Romano, F. Toni, M. Aurisicchio, G. Bertanza, Automatic evaluation of design alternatives with quantitative argumentation, Argument & Computation 6 (2015) 24–49. [9] A. Rago, F. Toni, M. Aurisicchio, P. Baroni, Discontinuity-free decision support with quantitative argumentation debates., in: KR, 2016, pp. 63–73. [10] L. Amgoud, J. Ben-Naim, D. Doder, S. Vesic, Acceptability semantics for weighted argumentation frameworks, in: IJCAI, 2017, pp. 56–62. [11] N. Potyka, Continuous dynamical systems for weighted bipolar argumentation, in: KR, 2018, pp. 148–157. [12] T. Mossakowski, F. Neuhaus, Modular semantics and characteristics for bipolar weighted argumentation graphs, arXiv preprint arXiv:1807.06685 (2018). [13] N. Potyka, Extending modular semantics for bipolar weighted argumentation, in: Int.
Conference on Autonomous Agents and MultiAgent Systems (AAMAS), 2019, pp. 1722– 1730. [14] N. Potyka, Interpreting neural networks as gradual argumentation frameworks, in: AAAI
Conference on Artificial Intelligence (AAAI), 2021, pp. 6463–6470. [15] Y. LeCun, Y. Bengio, G. Hinton, Deep learning, nature 521 (2015) 436–444. [16] C. Louizos, M. Welling, D. P. Kingma, Learning sparse neural networks through l_0 regularization, in: Int. Conference on Learning Representations, ICLR, OpenReview.net, 2018, p. Virtual. [17] S. Han, H. Mao, W. J. Dally, Deep compression: Compressing deep neural network with pruning, trained quantization and hufman coding, in: Int. Conference on Learning Representations (ICLR), 2016, p. Virtual. [18] C. Louizos, K. Ullrich, M. Welling, Bayesian compression for deep learning, in: Int.
Conference on Neural Information Processing Systems (NIPS), Curran Associates Inc., Red Hook, NY, USA, 2017, p. 3290–3300. [19] C. Tai, T. Xiao, X. Wang, E. Weinan, Convolutional neural networks with low-rank regularization, in: Int. Conference on Learning Representations (ICLR), 2016, p. Virtual. [20] A. Rago, O. Cocarascu, F. Toni, Argumentation-based recommendations: Fantastic explanations and how to find them, in: Int. Joint Conference on Artificial Intelligence (IJCAI), 2018, pp. 1949–1955. [21] O. Cocarascu, A. Rago, F. Toni, Extracting dialogical explanations for review aggregations with argumentative dialogical agents, in: Int. Conference on Autonomous Agents and MultiAgent Systems (AAMAS), 2019, pp. 1261–1269. [22] N. Kotonya, F. Toni, Gradual argumentation evaluation for stance aggregation in automated fake news detection, in: Workshop on Argument Mining, 2019, pp. 156–166. [23] L. Amgoud, J. Ben-Naim, Evaluation of arguments in weighted bipolar graphs, in: European Conference on Symbolic and Quantitative Approaches to Reasoning with Uncertainty (ECSQARU), Springer, 2017, pp. 25–35. [24] N. Potyka, Open-mindedness of gradual argumentation semantics, in: Scalable Uncertainty Management (SUM), volume 11940 of Lecture Notes in Computer Science, Springer, 2019, pp. 236–249. [25] N. Potyka, A tutorial for weighted bipolar argumentation with continuous dynamical systems and the java library attractor, Int. Workshop on Non-Monotonic Reasoning (NMR), 2018. [26] N. Potyka, Foundations for solving classification problems with quantitative abstract argumentation, in: Explainable and Interpretable Machine Learning (XI-ML), CEURWS.org, 2020, p. Virtual. [27] J. Spieler, N. Potyka, S. Staab, Learning gradual argumentation frameworks using genetic algorithms, arXiv preprint arXiv:2106.13585 (2021). [28] M. W. Bazo, Learning quantitative argumentation frameworks using sparse neural networks and swarm intelligence algorithms, 2021. [29] P. Dondio, Towards argumentative decision graphs: Learning argumentation graphs from data, in: M. D’Agostino, F. A. D’Asaro, C. Larese (Eds.), Advances in Argumentation in Artificial Intelligence, CEUR-WS.org, 2021, p. Virtual.