Building Concise Logical Patterns by Constraining Tsetlin Machine Clause Size

1 Introduction

The TM [Granmo, 2018] is a novel approach to machine learning where groups of Tsetlin automata (TAs) [Tsetlin, 1961] produce logical (Boolean) expressions in the form of conjunctive clauses (AND-rules). As opposed to the blackbox nature of deep neural networks, TMs are inherently interpretable. Indeed, they produce models based on sparse disjunctive normal form, which is comparatively easy for humans to understand [Valiant, 1984]. Additionally, the logical representations combined with automata-based learning make TMs natively suitable for hardware implementation, yielding low energy footprint [Wheeldon et al., 2020].

TMs now support various architectures, including convolution [Granmo et al., 2019], regression [Abeyrathna et al., 2020c], deterministic [Abeyrathna et al., 2020b], weighted [Abeyrathna et al., 2020a], autoencoder [Bhattarai et al., 2023b], contextual bandit [Seraj et al., 2022], relational [Saha et al., 2022], and multiple-input multipleoutput [Glimsdal and Granmo, 2021] architectures. The independent nature of clause learning allows efficient GPUbased parallelization, providing almost constant-time scaling with reasonable clause amounts [Abeyrathna et al., 2021]. Several schemes enhance vanilla TM learning and inference, such as drop clause [Sharma et al., 2023] and focused negative sampling [Glimsdal et al., 2022]. These TM advances have enabled many applications: keyword spotting [Lei et al., 2021], aspect-based sentiment analysis [Yadav et al., 2021b], novelty detection [Bhattarai et al., 2022b; Bhattarai et al., 2021], semantic relation analysis [Saha et al., 2021], text categorization [Yadav et al., 2021a; Bhattarai et al., 2022a; Yadav et al., 2022], game playing [Giri et al., 2022], batteryless sensing [Bakar et al., 2022b; Bakar et al., 2022a], recommendation systems [Borgersen et al., 2022], and knowledge representation [Bhattarai et al., 2023a].

The TM is somewhat related to Logistic Circuits [Liang and Van den Broeck, 2019a], which are Probabilistic Circuits for classification with logical expressions. However, Logistic Circuits use local search to build tractable Bayesian models, learning to classify through stochastic gradient descent. The TM, on the other hand, constructs pure logical ANDrules from online TA-driven learning with global convergence properties [Jiao et al., 2023; Zhang et al., 2022]. Compared to binary and real-valued Logistic Circuits, the TM outperform them accuracy-wise on MNIST and Fashion-MNIST [Sharma et al., 2023]. The pure logical structure of TMs further allows model compression [Maheshwari et al., 2023], yielding a tiny memory footprint.

While TMs match or surpass deep learning accuracy for an increasing number of applications, large clause pools tend to produce longer clauses containing many literals (input features and their negation). As such, they become less interpretable. Further, longer clauses require more memory and increase the switching activity in hardware, consuming more power. There is currently no direct way to control the size of the clauses learned. The challenge lies in coordinating the decentralized TAs, each independently learning whether to include a specific literal per clause. Indeed, since the TAs seek frequent discriminative patterns, the clauses can become arbitrarily long. In short, current learning schemes seem inefficient when it comes to the size of the clauses they produce.

This paper introduces a novel variant of TM learning - Clause Size Constrained TMs (CSC-TMs) - where one can set a soft constraint on the clause size. CSC-TM revises the TA feedback policy for including literals into the clauses. Specifically, the new policy discourages including additional literals once the length of a clause surpasses a predefined constraint. The TAs instead immediately start expelling literals from the offending clause by reinforcing "exclude" actions. Accordingly, oversized clauses only appear transiently. Otherwise, the TM feedback scheme is left unchanged. The salient property of our approach is that the limited collections of literals ending up in the clauses maintain high discrimination power. Even with significantly constrained clause size, the performance of CSC-TM is not compromised compared with the other TM variants.

Paper Contributions: The contributions of the paper can be summarized as follows:

• We propose CSC-TM to constrain the size of the clauses by introducing a new policy for training TMs.
• We demonstrate that CSC-TM can indeed constrain clause size within an explicit limit, without compromising accuracy in classification, regression, and clustering.
• Using several examples, we show that the shorter clauses become more interpretable.
• We prove analytically that CSC-TM can converge to the intended basic operators when properly configured.
• We describe how constraining the length of the clauses is beneficial for power consumption in embedded hardware solutions due to the reduced switching activity of the clause logic.

2 Training TsetlinMachines with Constrained Clause Length

In this section, we outline the difference between the vanilla TM 1 and CSC-TM.

A TM processes a vector X = [x1, . . . , xo] of propositional (Boolean) features as input, to be classified into one of two classes, y = 0 or y = 1. Negating these features produces a set of literals L that consists of the features and their negated counterparts: L = {x1, . . . , xo, ¬x1, . . . , ¬xo}.

A TM uses conjunctive clauses to represent sub-patterns. The number of clauses is given by a user set parameter n. For a two-class classifier 2 , half of the clauses gets positive polarity (+). The other half gets negative polarity (-). Each clause C p j , j ∈ {1, 2, . . . , n/2}, p ∈ {-, +}, then becomes:

Here, j is the index of the clause, p its polarity, while Lpj is a subset of the literals L, Lpj ⊆ L. For example, the clause C + 1 (X) = ¬x1 ∧ x2 has index 1, polarity +, and consists of the literals L+1 = {¬x1, x2}. Accordingly, the clause outputs 1 if x1 = 0 and x2 = 1, and 0 otherwise.

1 For those who are not familiar with TM learning, please refer to: https://cair.github.io/ijcai 2023 clause rationing.html.

2 A multi-class classifier gets n clauses per class.

The clause outputs are combined into a classification decision through summation and thresholding using the unit step function u(v) = 1 if v ≥ 0 else 0:

Namely, classification is performed based on a majority vote, with the positive clauses voting for y = 1 and the negative for y = 0. The classifier ˆ y = u ((x1 ∧ ¬x2) + (¬x1 ∧ x2) - (x1 ∧ x2) - (¬x1 ∧ ¬x2)), e.g., captures the XOR-relation.

For training, a dedicated team of TAs composes each clause C p j . Each TA of clause C p j decides to either Include or Exclude a specific literal lk in the clause. A TA makes its decision based on the feedback it receives in the form of Reward, Inaction, and Penalty. There are two types of feedback associated with TM learning: Type I Feedback and Type II Feedback. Type I Feedback stimulates formation of frequent patterns, which suppresses false negative classifications. Type II Feedback, on the other hand, increases the discrimination power of the patterns, counteracting false positive classifications.

The difference between vanilla TM and CSC-TM lies in Type I Feedback. Type II Feedback remains the same for both schemes. Table 1 shows how CSC-TM modifies Type I Feedback to constrain clause size. The modification is marked by the red box. As seen, we introduce an additional condition for triggering the two leftmost feedback columns. These two columns make the clause mimic frequent patterns by reinforcing inclusion of "1"-valued literals with probability s-1 s and by reinforcing exclusion of "0"-valued literals with probability 1s . The two rightmost columns, on the other hand, exclusively reinforce exclusion of literals.

CSC-TM requires that the size ∥C p j (X)∥ of the clause is within a constraint b to give access to the two leftmost columns. Accordingly, as soon as the number of literals in the clause surpasses the constraint b, only Exclude actions are reinforced. The reason is that all the TA feedback then comes from the two rightmost columns, which reward Exclude and penalizes Include independently with probability 1s . As a result, the clause starts expelling literals when oversized, which means that oversized clauses only appear transiently.

In the following sections, we analyze the impact that CSCTM has on convergence. We further investigate how constraining clause size affects accuracy in classification, regression, and clustering. Finally, we discuss effects on hardware complexity and energy consumption.

3 Convergence Analysis

Here we analyse the convergence property of two basic operators, namely the XOR and the OR operators, using the CSCTM. Specifically, we show how the literal budget influences their convergences. We select those two operators for analysis mainly due to their simplicity and representativeness.

3.1 XOROperator

Here we study the convergence of the XOR operator when only one literal is given, i.e., (∥C i j (X)∥ = 1)3 . We can then show that if the budget is not sufficient to represent a subpattern, the sub-pattern cannot be learnt. For XOR, a subpattern means [x1 = 1, x2 = 0] or [x1 = 0, x2 = 1], i.e., any one input pattern that can trigger y = 1. Clearly, the subpatterns in XOR are mutual exclusive, and one literal cannot capture fully any sub-pattern of XOR. In what follows, we will show how the TM reacts upon training samples of XOR.

As already proven in [Jiao et al., 2023], the vanilla TM can converge almost surely to the intended sub-pattern, i.e., C i j = ¬x1∧x2, when the training samples in Table 2 is given. However, when (∥C i j (X)∥ = 1) is given in addition, the only absorbing state of the system, i.e., C i j = ¬x1 ∧ x2, disappears, making the system recurrent. More specifically, for vanilla TM, according to [Jiao et al., 2023], when the training samples for x1 = 0, x2 = 1, y = 1 is given to the system and when TA31=Exclude, TA32=Include, and TA34=Exclude, the following transition 4 holds for TA33 .

3 Here we follow the index of clause used in [Jiao et al., 2023], where i in Ci j is the index of class rather than the clause polarity. In [Jiao et al., 2023], we did not specify the polarity of the clause in the proof.

4 It is the 2nd transition of Case 1 in Subsection 3.2.1 in [Jiao et al., 2023]. The transition diagram is derived based on the current status of the system and the input training samples. For details please refer to [Jiao et al., 2023].

Here the superscript of TA31 is the clause index and the subscript is the TA index. TA31 has two actions, i.e., Include or Exclude x1. Similarly, TA32 corresponds to Include or Exclude ¬x1. TA33 and TA34 determine the behavior of the x2 and ¬x2, respectively. C3 is the 3rd clause and here the class index i in the clause notation is removed for simplicity. P and R here mean penalty and reward respectively while I and E denote Include and Exclude respectively. u1 is a constant in [0, 1].

Clearly, for vanilla TM, the new training sample x1 = 0, x2 = 1, y = 1 will encourage TA33 to be included, reinforcing C3 being in the form ¬x1 ∧x2. However, when the constraint (∥C i j (X)∥ = 1) is given in addition, the transition of TA33 changes to:

The above change will make the only absorbing state, i.e., C3 = ¬x1 ∧ x2, disappear. Understandably, given one literal that has already been included, the system will not encourage more literals to be included. Therefore, the TM, given the clause length being 1, cannot almost surely capture any sub-pattern in XOR. The above analysis also confirms that the newly added length constraint operates as expected, i.e., it indeed discourages more literals to be included once the length budget is reached. The complete proof can be found here 5 .

3.2 OROperator

Now we study the OR operator, aiming at showing the fact that when the budget of the literals in a clause is sufficient to represent a sub-pattern (or a group of sub-patterns), the TM can learn the intended sub-pattern (or the intended group of sub-patterns). Before we study the convergence for the OR operator, let us revisit its nature. There are three sub-patterns that can rigger y = 1, i.e., [x1 = 1, x2 = 1], [x1 = 0, x2 = 1], and [x1 = 1, x2 = 0]. To represent each of the sub-pattern explicitly (or individually), we need two literals. However, two sub-clauses can also be represented jointly by one literal. Clearly, C = x1 can cover both [x1 = 1, x2 = 1] and [x1 = 1, x2 = 0] while C = x2 can cover both [x1 = 1, x2 = 1] and [x1 = 0, x2 = 1]. This gives the TM possibility to learn the intended OR operator with clauses that has one literal, in collaboration with the hyper-parameter 6 T .

Based on the analysis in [Jiao et al., 2021], we understand that if T = ⌊ m2 ⌋, and when T clauses learn x1 and the other T clauses learn x2, the system is absorbed. This absorbing state learns the intended OR operator and also coincides with the requirement for the CSC-TM, which indicate that the OR

5 https://cair.github.io/ijcai 2023 clause rationing.html.

6 The hyper-parameter T is utilized to guide different clauses to learn distinct sub-patterns. The details can be found in [Jiao et al., 2023].

operator can possibly be learnt by the CSC-TM given literal length budget 1. In what follows, we show that the other absorbing states for the OR operator, i.e., with clauses that require more than one literal, will not be encouraged due to the newly added length constraint.

Similar to the analysis for the XOR case, once we revisit the transitions for the absorbing states with 2 literals, we realized that the absorbing states are not absorbing any more. More specifically, the Type I Feedback will encourage the included literal to be excluded. For example, in vanilla TM, for the sub-pattern below:

the transition of TA3 when its current action is Include and TA1 =Include and TA2 =Exclude, namely

Clearly, the state, i.e., x1 ∧x2 is not absorbing any more, and the new constraint encourages the TA with included literal, in this case TA3, to move towards "Exclude". Similar cases apply also to [x1 = 1, x2 = 0] and [x1 = 0, x2 = 1]. Based on the above analysis, we can conclude that the CSC-TM can still learn OR operator but only with clauses that include 1 literal.

Note that although the length of the clauses are constrained, it may still happen that the length of a clause is over the budget. First, the length of a clause may be over the budget when the system update is blocked. Consider an extreme case for the OR operator when T clauses have x1 and T - 1 clauses follow x2. In this situation, due to the randomness, a clause may become ¬x1 ∧ x2 based on a single training sample. In this situation, any future system update is blocked by T and the system is absorbed. Nevertheless, although this event may happen, the probability is very low. The reason is that it requires that both TAs happen to be in the boundary states at the Exclude side. This must happen at the same time as a training sample triggers the transitions in both TAs toward the Include side.

Another reason of being over the budget is that the Type II Feedback is not constrained and can produce clauses with more literals than the budget. In this case, the TAs of the included literals will all be in the boundary states, and the literals will be quickly swapping between being included or excluded in the clause, until the training stops. Type II Feedback ensures that all the literals are explored. During literal exploration, although the length of the clause can be large, the accuracy stays low until an accurate literal configuration is found. Accordingly, the included literals at boundary due to Type II Feedback do not necessarily contribute positively to the classification. This can be observed from the numerical results for image processing when the literal budget is low (demonstrated for CIFAR-2 and MNIST with convolution in Table 3). Specifically, the convolution needs more literals so that the clause position also can be stored. With too few literals, the clauses precision suffers, triggering a large degree of Type II Feedback. The clauses will then be unable to settle because of the tight literal budget. As a result, the TAs of the included literals will not be able to progress deeply into the Include side of the their state space. Consequently, Type II Feedback will persistently continue to experiment with new candidate literals, without finding a sufficiently sparse highaccuracy configuration.

4 Empirical Results

In this section, we investigate the performance of CSCTM, focusing on accuracy and interpretability. To this end, we evaluate classification, regression, and clustering performance on various datasets spanning natural language, images, board games, and tabular data. The experiments use a CUDA implementation of CSC-TM and runs on Intel Xeon Platinum 8168 CPU at 2.70 GHz and a Nvidia DGX-2 with Tesla V100 GPU. We describe the details of each task in respective subsections and summarize the findings in Tables 3, 4, and 5.

4.1 Natural Language Processing

We first evaluate CSC-TM on five NLP datasets: BBC sports [Greene and Cunningham, 2006], R8 [Debole and Sebastiani, 2005], TREC-6 [Chang et al., 2002], SemEval 2010 Semantic Relations [Hendrickx et al., 2009], and ACL Internet Movie Database (IMDb) [Maas et al., 2011]. 7 Starting from a maximal constraint of 1, we progressively increase the literal constraint to 64, recording the resulting accuracy and the average number of literals included per clause. For BBC Sports, we notice that a literal constraint of 8 yields the maximum accuracy of 99.1%. Similarly, the maximum accuracy for TREC and R8 are achieved with literal counts 32 and all, respectively. We further observe that incorporating all the literals reduces the accuracy in BBC and TREC. For all the datasets, the average literal count drops significantly with literal budgeting. For instance, the literal constraint of 32 for BBC Sports gives 2.64 literals per clause on average, whereas the average is 44.14 without constraints. Accordingly, the clause length is considerable shortened, and the clauses can be quickly glanced by humans for interpretation. Similar trends can also be seen for the other data sets.

Consider as an example the results from R8 in Table 3. Notice how a constraint as strict as 4 still almost maximizes accuracy. Indeed, the NLP results overall show that CSCTM allows us build concise and accurate propositional rules for better understandability. The improved interpretability is showcased in Figure 1, where we retrieve a few typical clauses from the "Football" class of BBC Sports. The literalconstrained clauses (in red) only contain 2-3 literals, and they clearly relate to the "Football" class. The vanilla clauses (in yellow), however, contain a much larger number of literals and rely extensively on feature negation.

7 For TM hyperparameters in BBC Sports, TREC, and R8, we use 8000 clauses, a voting margin T of 100, and specificity s of 10.0.

4.2 Image Processing

We evaluate our approach on two image datasets: MNIST and CIFAR-2 (a two-class variant of CIFAR-10 that groups vehicle images and animal images into two separate classes) 8 . For MNIST, we perform experiments utilizing both vanilla and convolutional TM with constrained clause length. Observe from Table 3 how a constraint as small as 8 still yields competitive accuracy. Specifically, the maximum accuracy is obtained in CIFAR-2, MNIST, and MNIST w/conv. with literal constrains 64, 16, and 16, respectively. Also notice that CSC-TM on average keeps the number of literals per clause well below the set constraints. For example, for the latter constraints, the corresponding average number of literals per clause are respectively 34.1, 10.8, and 13.4. Without clause length constraints, however, the corresponding average number of included literals are 60.4, 47.7, and 40.3. Finally, notice how setting a too tight literal budget (below 4) for MNIST w/conv. and CIFAR-2 increases the average number of literals used. This can be explained by CSC-TM not finding sufficiently accurate patterns. As a result, it stays in literal exploration mode throughout the epochs. In conclusion, we observe that the maximum accuracy can be achieved using significantly fewer literals per clauses using CLC-TM. This allows us to significantly reduce computational complexity and increase the readability of the clauses.

8 For hyperparameters, we adopt 8000 clauses per class, a voting margin T as 10000, and specificity s as 5.0 in the MNIST experiments. For CIFAR-2, the number of clauses is 8000, T is 6000, and s is 10.0.

To investigate how the number of clauses interact with the literal constraint, we now measure the effect of jointly varying the number of clauses and literal budget. From Table 4, we observe a graceful degradation of accuracy as the number of clauses drops to 250 and the literal budget falls to 1. Also notice that fewer clauses produces fewer literals per clause on average. We believe this is the case because when fewer clauses are available, they must become less specialized to solve the task. However, when looking at attaining maximum accuracy, we observe that 1000 clauses require more literals than 4000 (32 vs 16 literals on average per clause). The reason may be that fewer clauses needs to be more specific to compensate and maintain accuracy. As we increase the number of clauses, each clause includes fewer literals, solving the task as an ensemble. In conclusion, CSC-TM allows a fine-grained trade-off between the length of clauses and the number of clauses.

It is interesting to compare the CSC-TM performance against logistic circuits [Liang and Van den Broeck, 2019b]. The binary version of the logistic circuits classifier achieves 97.8% accuracy on MNIST, while the real-valued version obtains 99.4%. The CSC-TM achieves 98.42% test accuracy for MNIST for configurations of 8000 clauses and a literal budget of 16. With convolution the CSC-TM obtains 99.33% test accuracy, also with a literal budget of 16.

4.3 Self-Supervised Learning

For the self-supervised learning task, we evaluate how the clause literal budget influences both training time and interpretability. Here, we evaluate the previously proposed LabelCritic TM (LCTM) [Abouzeid et al., 2022], which is a novel architecture to self-learn data samples' labels without knowing the ground truths. The LCTM architecture runs on top of the standard CUDA TM implementation and starts by randomly initializing the data labels. Thereafter, it performs hierarchically clustering while learning the sub-patterns and their associated labels. Eventually, the learned sub-patterns represent interpretable clusters, each associated with a single supporting and a single discriminating clause. As a result, the method is interpretable, however, can still benefit from smaller clauses.

Table 5 shows the empirical results from different clause literal budgets on a subset of the MNIST dataset. Here, LCTM is to learn the labels and sub-patterns of the MNIST samples, associated with the digits "One" and "Zero". The results captures how the literal constraint influences both the training time and the interpretability. The interpretability metrics are as follows. Supporting interpretability is the percentage of the positive polarity clauses that a human verifies as recognizable. See Figure 2 for examples of clauses that are deemed interpretable and not interpretable. Similarly, discriminating interpretability is the percentage of negative polarity clauses that are recognized by humans.

As shown in Table 5, when the budget was reduced to 1, 200, the LCTM was both faster and more interpretable. Clearly, constraining the size of clauses yielded both increased interpretability and learning speed in our evaluations.

4.4 Regression

We use the Energy Performance dataset to evaluate regression performance based on [Abeyrathna et al., 2020c]. The results are reported in terms of Mean Average Error (MAE). In brief, Table 3 shows that the MAE decreases, i.e., the performance is better, as the literal budget is increased from 1 to 64. Again, the degradation of performance is graceful, and one can trade off clause size against MAE.

4.5 Board GameWinner Prediction

We here use the Hex game as an example of reinforcement learning with CSC-TM, where the task is to predict the winner (value) of any given board configuration. To investigate how the prediction accuracy varies for CSC-TM, we compare the vanilla TM [Giri et al., 2022] with the CSC-TM for distinct literal budgets. The details of the experiment setup can be found in [Giri et al., 2022]. Bottom row of Table 3 summarises how the accuracy varies with the literal budget. We observe that a literal budget of 64 reaches the maximum accuracy of 82.17% against an accuracy of 81.43% for all the literals. However, it is to be noted that the smaller literal budgets provide relatively poor accuracy. We believe this is the case because describing a Hex board configuration accurately generally requires information on a sufficient number of piece positions due to the nature of the game.

5 Hardware Complexity and Energy Consumption Analysis

TM hardware accelerators will typically be implemented by either Field Programmable Gate Arrays (FPGAs) or Application Specific Integrated Circuits (ASICs). In most cases the dominating part of the energy consumption is related to the switching of digital circuits. It should be noted, however, that the static power consumption due to transistor leakage current for high performance processes can reach up to 30% of total power [Dally et al., 2016]. With implementations in low power processes the static power consumption will be less.

The dynamic power, P , consumed by a digital circuit with load capacitance C, operating frequency f, supply voltage VS, and an activity factor α (transitions per clock cycle) is given by Eq. (4) [Dally et al., 2016],

Limiting the number of literals will reduce the α value in several gates that implement the clause logic. Only those gates that process the included literals will switch and consume energy. The reduction in energy consumption of the clause logic can therefore roughly be estimated to b lave , where b is the clause size constraint and lave is the average number of literals in the model without the length constraint. The exact savings will depend on the dataset.

The classical approach [Wheeldon et al., 2020] for implementing clause logic is shown in Figure 3. Here each literal l1, . . . , l2o is either included or excluded by the associated include signal i1, . . . , i2o (active low) by using OR-gates. The include signals will typically all be simultaneously available from a register. The outputs from the OR-gates are then fed to a wide-input AND-gate, which will normally be implemented by several smaller AND-gates connected in a tree-structure to reduce path delay. Clearly, for a certain fixed application, given a smaller number of included literals, we can reduce the number of OR-gates to b, and use an AND gate with only b inputs. In this way, the hardware complexity and power consumption can be reduced. For a general case, where the TM needs to be programmable in distinct applications, we need to have sufficient amount of available literals. Nevertheless, CSC-TM still has benefits in reduced switching activity, thus saving power.

It should be noted that it is only the energy consumption related to the clause logic that is affected by constraining clause size. The ensuing hardware processing, e.g., with clause weighting and summation is not affected. However, for systems with a huge number of clauses, the clause logic will occupy a significant part of the digital circuitry, and reducing its switching activity can enable significant energy savings.

An important system level benefit of literal budgeting is the time required for a model to be loaded from external or onchip memory into registers in the ASIC or FPGA. During this time the system's processor and the data transfer itself will consume energy. With less included literals, the model size and thus the load time can be reduced with a suitable encoding scheme, such as Run Length Encoding (RLE) [Bakar et al., 2022a]. Reduction of the model size is also beneficial for other embedded TM solutions based on low-power microcontrollers.

6 Conclusions and FutureWork

In this paper, we proposed CSC-TM - a novel TM mechanism that constrains the size of clauses. We argued how limiting the number of literals significantly reduce switching activity in hardware, and thereby power consumption. We further analyzed and confirmed the convergence of CSC-TM. Experimental results showed that CSC-TM can achieve the same or even better accuracy with shorter clauses, providing better interpretability. Future work includes introducing other kinds of constraints, with the intent of supporting constrained machine learning in general.

Acknowledgments

This work is supported in part by the project "Logicbased Artificial Intelligence Everywhere: Tsetlin Machines in Hardware" and funded under the grant number 312434 of the Research Council of Norway. This work is also supported in part by the project "Unleashing the Sustainable Value Creation Potential of Offshore Ocean" and funded under the grant number 328724 of the Research Council of Norway.

Contribution Statement

All authors have contributed equally in terms of conceptualization, experimentation and production of this paper.