Learning Interpretable Relational Structures of Hinge-loss Markov Random Fields

1 Introduction

Machine-learning models that possess superior interpretability and ease of specification without compromising modeling power have the potential to positively impact numerous downstream application domains that use them. In this work, we focus on one such recently developed inherently interpretable model that efficiently combines logic and uncertainty, hinge-loss Markov random fields (HL-MRFs) [Bach et al., 2017]. HL-MRFs are specified using probabilistic oft logic (PSL), which uses logical first-order clauses to capture domain knowledge. The weights of these clauses are learned in a supervised manner by grounding them in data instances with ground truth values. The capability of the model to represent and reason about complex relational dependencies in the data using continuous-valued variables, while simultaneously being easy to encode these dependencies using logical clauses/rules makes it a good choice in modeling numerous applications, especially in computational social science.

In this work, we present an approach to learn meaningful structures of HL-MRFs by adapting a deep reinforcement learning (RL) algorithm, asynchronous advantage actor-critic (A3C) [Mnih et al., 2016]. The possibility of tackling huge state spaces asynchronously in A3C together with scalable inference in HL-MRFs paves the way for developing a scalable structure learning algorithm that allows for diverse exploration. Further, guiding this exploration using domainspecific semantic constraints is helpful in learning meaningful structures that can potentially also achieve good prediction performance.

Specifically, we make the following main contributions:

1. We present asynchronous advantage actor-critic for structure learning (A3SL), a deep RL algorithm for learning interpretable structures of HL-MRFs that takes into account semantic constraints on domain-specific insights to guide the discovery of structures while simultaneously maintaining good prediction performance and ability to learn from realworld data instances.
2. We encourage the learning of diverse models through exploration by including a diversity constraint on the actions. This can potentially help the domain expert choose the model with the best semantic meaning from a group of models that have similar prediction performance.
3. We evaluate our structure learning algorithm on two important real-world computational social science applications: i) modeling recovery from alcohol use disorder, and ii) detecting bullying in online interactions. We choose these applications as there is existing work on applying HL-MRFs in these domains and we are able to make a direct comparison of the learned rules from A3SL with the existing manually specified models. We show that the structures learned by our algorithm achieves better prediction performance when compared with structures learned using a greedy structure learning algorithm, structure learning algorithms developed for Markov logic networks (MLNs) (Hypergraph lifting [Kok and Domingos, 2009] and Grafting-light [Zhu et al., 2010]), and manually defined model structures.
4. We demonstrate that our model is able to learn complex clauses that encode network interactions such as the friend

network and meaningful latent variables through a complex combination of features and target variables using semantic constraints. We also demonstrate that our learned clauses resemble the manually specified clauses capturing the same semantic meaning, while also learning others via exploration. Ours is the first structure learning algorithm that directly optimizes for interpretability, learning networked dependency structures, and learning meaningful latent variables in the problem formulation itself, thus yielding structures with enhanced interpretability and semantic coherence.

2 RelatedWork

Perhaps the earliest work in structure learning for undirected models is by McCallum et al. for Markov Random Fields, in which a greedy search is used for either adding or removing candidate features [McCallum, 2003]. Structure learning in MRFs has also been cast as a feature selection problem and solved using L1 regularization over features [Zhu et al., 2010; Khosravi et al., 2010]. Structure learning has also been studied in SRL models such as Markov Logic Networks (MLNs), where the first approach is to employ a greedy search technique for this problem [Kok and Domingos, 2005]. Bottom-up approaches that generate clauses by using paths to capture structural motifs in the data have also been proposed, where finally the paths are ranked according to a path ranking algorithm [Mihalkova and Mooney, 2007; Kok and Domingos, 2010; 2009]. Most recent algorithms for structure learning in MLNs use functional gradient boosting and online learning to create scalable variants of existing structure learning algorithms [Khot et al., 2011; 2015; Huynh and Mooney, 2011]. Learning the structure of MLNs specific to tasks of interest have also been developed using inductive logic programming [Biba et al., 2008], L1regularized learning [Huynh and Mooney, 2008], and iterative local search [Biba et al., 2008]. Embar et al. [Embar et al., 2018] recently develop a greedy path-based structure learning algorithm for PSL.

The primary differences between our approach and existing work are: i) we guide the model into learning structures that bring out the modeling capabilities of SRL modelsmodeling relational dependencies and latent variables in the data/domain, and ii) we approach the structure learning problem from the perspective of the domains in which they would be most helpful, allowing us to demonstrate the encoding of domain-specific semantic constraints to learn models that are both meaningful and have good prediction performance, while existing approaches are primarily data-driven.

3 Deep Reinforcement Learning for Structure Learning in HL-MRFs

3.1 Hinge-loss Markov RandomFields

HL-MRFs are a recently developed scalable class of continuous, conditional graphical models [Bach et al., 2017]. HLMRFs can be specified using probabilistic soft logic (PSL) [Bach et al., 2017], a first-order logic templating language. In PSL, random variables are represented as logical atoms and weighted clauses define dependencies between them of the form: λ : P (a) ∧ Q(a, b) → R(b), where P, Q, and R are predicates, a and b are variables, and λ is the weight associated with the clause. The weight of the clause c indicates its importance in the HL-MRF model, which is defined as

where P(Y|X) is the probability density function of a subset of logical atoms Y given observed logical atoms X, φc(Y, X) is a hinge-loss potential corresponding to an instantiation of a clause c, and is specified by a linear function lc and optional exponent ρc ∈ {1, 2}. Since HL-MRFs operate on continuous random variables and encode dependencies using potential functions that are convex, MAP inference in these models is always a convex optimization problem. The combinatorial explosion of state space during inference in SRL models including MLNs [Richardson and Domingos, 2006] makes it computationally challenging for designing a structure learning algorithm that requires repeated inference. In contrast, the possibility of fast exact inference in HL-MRFs opens up opportunities to capitalize recent advancements in deep RL to learn HL-MRF structures.

The logical conjunction of Boolean variables X ∧ Y can be generalized to continuous variables using the hinge function max{X+Y -1, 0}, which is known as the Lukasiewicz t-norm. Disjunction X ∨ Y is relaxed to min{X + Y, 1}, and negation ¬X to 1 - X. For example, A ⇒ B = ¬A ∨ B has a distance to satisfaction which is a hinge function, max{A-B, 0}. Our approach to structure learning focuses on the learning logical constructs that particularly bring out the modeling capabilities in HL-MRFs such as:

1. Relational dependencies and network structures: friends(U, U1) ∧ usesAlcoholWord(U1, P ) → ¬recovers(U ), which captures if user U's friend U1 uses alcohol words frequently in their posts, that could potentially negatively influence U's recovery.

2. Latent variables: Incorporatingmeaningful latent variables can be helpful in learning abstractions that enhance modeling capability and interpretability.

3.2 ProblemDefinition

The structure learning problem can be modeled as a space search and sequential decision problem using reinforcement learning. Since HL-MRFs are specified using templated firstorder logic clauses (also referred to as rules) in continuous space using the probabilistic programming language PSL, our problem translates to learning the structure of these clauses. We know that a first order logic clause has the form body → head, and in PSL head only can contain one predicate and body has the form b1 ∧ b2 ∧ ... ∧ bN , N < L, where L denotes the maximum length of a clause. And, the order of predicates b in a clause within the body and clause in the list of clauses do not matter. A clause of the structure b1 ∧ b2 ∧ ... ∧ bN → head can be represented in different ways as shown below.

Each clause has a formula ¬b0 ∨ ¬b1 ∨ ... ∨ ¬bN , where we replace head as b0 for readability. This can be represented as a sequence b0, b1, ..., bN, END, where END signifies the end of the sequence. If current length of sequence equals to L, we stop appending the current sequence. We can see that when we generate a sequence we do not need to specify which predicate is head in a clause beforehand, since inherently the model is undirected. After clause generation, we can randomly choose any predicate ¬bi as head, so finally the clause becomes b0 ∧ ... ∧ bi-1 ∧ bi+1 ∧ ... ∧ bN → ¬bi. In practice, we can always choose the target predicate as head for ease of interpretability. Here, any predicate bi can refer to the original predicate or its negative counterpart. Not all the predicates have meaningful negative counterparts, for example for network predicates, which capture relationship between two users, such as replies(U1, U2, I): user U1 replies to U2's message I, the negative counterpart ¬ replies(U1, U2, I) is not very meaningful as we are primarily interested in modeling interactions and not lack thereof.

3.3 A3SL: Asynchronous Advantage Actor-Critic Structure Learning Algorithm for PSL

We present our asynchronous advantage actor-critic structure learning algorithm, A3SL, which adapts a recently developed neural policy gradient algorithm asynchronous advantage actor-critic (A3C) [Mnih et al., 2016] for the structure learning problem. A3C is one of the most general and successful learning agents to date and has been shown to perform well in discrete and continuous action spaces. A3C's ability to asynchronously execute multiple agents in parallel on multiple instances in the environment offers both algorithmic improvements that allow for effective integration of feedforward and recurrent deep neural network architectures in RL algorithms as well as practical benefits in speed, making it an appropriate choice for our structure learning problem. The description of A3SL is given in Algorithm 1 and the details are given in Algorithm 2.

Environment - State, Action, and Reward

Here, we define the problem space and reinforcement learning algorithm setup.

Environment ε: Our environment consists of predicates for features (denoted by X), target variables (Y ), and latent variables (Z) and data corresponding to X and ground truth data for Y , except latent variables.

State st: Each intermediate state st at time t comprises of either a partially constructed or a complete set of firstorder logic clauses, denoted by C. The asynchronous nature of A3SL helps in combating the combinatorial explosion in the state space, making it an appropriate fit for the problem.

Action at: During an action at at time t the algorithm adds a new predicate to the current clause or chooses to return the clause by adding an END to the clause. The algorithm can choose from the action space of all the defined predicates X, Y, Z, and their negative counterparts.

Transition: The environment evolves by updating the current clause c with the predicate chosen during at.

Reward rt and cumulative reward Rt: rt is the reward at a given time step t. Rt = ∑∞k=0 γ k rt+k is the total accumulated reward from time step t with discount factor γ ∈ (0, 1]. In our setting, Rt is equal to the value of the objective function J (see below). As in a standard reinforcement learning setting, V π (s) = E[Rt|st = s] is the expected return for fol- Algorithm 1 A3SL: Asynchronous advantage actor-critic structure learning algorithm for each actor-learner thread Input: A collection of predicates, X = {xj, j = 1, ...,m}, Y = {yj , j = 1, ..., n}, Z = {zj , j = 1, ..., k}, Ground truth labels Yg for Y

Let C = {c0, c1, .., cM} denote set of first-order logic clauses

Let Clist denote list of C obtained with reward > 0.

Output: Optimal C denoted by C∗

Global Variables: Input and output variables, parameter vectors θ and θv, counter T, convergence criteria Tmax, thread convergence criteria tmax.

• 1: function C∗ = A3SL() 2: Initialize T = 0, thread step counter t = 0 RuleEnd = false, ListEnd = false, i = 0, C = ∅, tstart = t
• 3: repeat
• 4: if ListEnd then
• 5: Initialize ListEnd = false, i = 0, C = ∅
• 6: Synchronize thread-specific local copies of parameters θ′ = θ, θ′v = θv
• 7: Obtain state st = Ψ(C), where Ψ is the first-order logic embedding function
• 8: repeat
• 9: PSL-Actor(θ′ )
• 10: until ListEnd or t - tstart == tmax
• 11: PSL-Critic(θ′ , θ′v)
• 12: until T > Tmax
• 13: C∗ = optimal C fromClist
• 14: return C∗

lowing policy π from state s. The goal of the agent is to maximize the expected return from each state st. During training, the agent learns to maximize the cumulative reward, so the model can find the corresponding optimal model structure. Objective: We define the objective function J = L(Y,X)+ Interpretability Constraint, where L(Y,X) is the HL-MRF probability density, L(Y,X) = logP(Y |X), given by Eqn 1. Given a set of target predicates Y , a PSL model m consists of model structure C and corresponding weight vector Λ, comprising of individual clauses c and weights λc ∈ R+. Interpretability Constraint consists of the constraints on the total number of clauses, the maximum possible length of a clause, and the domain-specific semantic constraints. These qualities have been shown to enhance interpretability in Bayesian clause sets [Wang et al., 2015; Angelino et al., 2018; Wang et al., 2017a; Letham et al., 2015]. The combination of semantic constraints and a performance-based utility allows our algorithm to learn structures that are interpretable and data-driven, thus optimizing for both while being able to rectify any domain-specific intuitions that are not true in the data. Hence, the objective function J is defined as,

where αlen, αnum, and αsem parameters denote the strength of the different constraints and Dist(c) denotes the deviation of clause c from semantic constraints discussed below. A3SL returns the value of C, Λ that maximizes the objective function.

Algorithm 2 A3SL algorithm details for updating action and reward

1: function PSL-Actor(θ′ ) 2: Perform action at ∈ {X, ¬X, Y, ¬Y,Z, ¬Z, END}, according to policy π(at|st; θ′ ) 3: // Finding end of clause 4: if at == END then 5: RuleEnd = true 6: else 7: Append at to ci 8: if |ci|==N then 9: RuleEnd = true 10: // Checking validity of clause 11: if RuleEnd then 12: i++, RuleEnd = false 13: if ci is invalid or i==M then 14: ListEnd = true 15: // Calculating weights and reward 16: if ListEnd then 17: Initialize weights Λ for C 18: Perform weight learning and update Λ 19: Obtain reward rt = Utility(C, Λ) 20: Add C to Clist 21: else 22: Obtain reward rt = 0 23: New state st+1 = Ψ(C) 24: t = t +1 25: T = T +1 1: function PSL-Critic(θ′ , θ′v) 2: Reset gradients dθ = 0 and dθv = 0 3: R = { 0 for terminal st V (st, θ′v) for non-terminal st 4: for k ∈ {t - 1, ..., tstart} do 5: R = rk +γR 6: Accumulate gradients wrt θ′ : dθ = dθ + ∇θ′ (log π(ai|sk; θ′ )(R - V (sk; θ′v)) + β ∗ H(π(st))) 7: Accumulate gradients wrt θ′v: dθv = dθv + ∂(R - V (sk; θ′v))2 /∂θ′v 8: Perform asynchronous update of θ using dθ and θv using dθv

Constraints on Actions

We incorporate constraints on actions to guide the algorithm to discover clause structures that are grammar compliant, semantically coherent, and diverse. After clause construction, it is first checked for compliance with PSL grammar. If not compliant, the list of clauses excluding the current clause is returned. The following constraints encode necessary grammar compliance with PSL.

1. If the algorithm chooses a redundant predicate in the same clause, the action is ignored.
2. After clause construction, if there is no target or latent predicate in the learned clause, then it is discarded.

Next, we illustrate the capability of our model to encode domain-specific semantic constraints using one of the computational social science application domains, modeling recovery from alcohol use disorder (AUD). By intuition, presence of alcohol-related signals indicates relapse (denoted by ¬recovery and sobriety-related signals indicates recovery (denoted by recovery). These right reasons can be captured using simple logical clauses such as the ones given below, which can guide the discovery of model structures that capture these reasons [Ross et al., 2017]. We use a distance function, Dist(c) to capture if the learned clause structure complies with or deviates from the right reasons identified by the expert: Dist(c) = 0, if the clause complies with the right reasons and Dist(c) = 1, otherwise.

1) alcohol signal ⇒ ¬recovers; 2) sober signal ⇒ recovers 3) alcohol signal ∧ ¬recovers ⇒ ¬sober signal 4) sober signal ∧ recovers ⇒ ¬alcohol signal

For example, consider the clause: usesAlcoholWord(U,AW) ⇒ ¬recovers(U), the distance to the right reason is 0, because it satisfies right reason 1 above. For the rule: usesAcoholWord(U,AW) ∧ containsSoberWord(U,I,SW) ⇒ ¬recovers(U), the distance to the right reason is 0, because it satisfies the right reason 4. But for rule: containsSoberWord(U,I,SW) ⇒ ¬recovers(U), the distance to the right reason is 1. From the perspective of the objective function, we want the weights of the clauses that do not conform to the right reasons to have much smaller values, or even 0, which means the clause list excludes the clause corresponding to the wrong reason.

We may not always have access to this extra domain knowledge or the "right reasons". In this case, we can learn multiple diverse policies [Wang et al., 2017b; Haarnoja et al., 2017; Hong et al., 2018] so an appropriate policy can be selected from them. To enable this, during training, we encourage diverse exploration by adding an entropy prior in the policy gradient objective function as follows,

where the baseline bt(st) is approximated by the value function V π (st) and H(.) is the entropy. The diverse exploration across models results in diverse HL-MRF models after training which are all capable of good prediction performance.

To implement the constraints, during training, we relax the clause length and the number of clauses constraints in the objective by setting maximal clause length L and maximal clause number M. We encode the set of clauses corresponding to each state st in vector space using one-hot encoding [Wang and Cohen, 2016]. We incorporate the semantic constraints during weight learning in HL-MRFs by including them in the maximum-likelihood weight update as shown in Equation 3. The second term corresponds to the semantic distance indicating deviation from the semantic constraints.

With the above relaxations, we use area under the ROC curve as the Utility function to calculate the reward. Hence, Rt = AUC-ROC, and rt=0, when t is not terminal, and rt = AUCROC, when t is terminal. In our experiments, the value and the policy network both use a 3-layer feed-forward neural network architecture with tanh as the activation function. We set tmax = 6 and Tmax = 100, 000. We use distributed implementation using multi-threading that takes advantage of the asynchronous and parallel nature of the algorithm.

4 Experiments

We conduct experiments to answer the following questions:

1. How well does our learned model structures perform in real-world prediction problems? We evaluate the efficacy of our learned structures in two computational social science modeling scenarios: i) predicting recovery from/relapse into alcohol use disorder (AUD) using a combination of behavioral, social, and linguistic signals, and ii) detecting bullying using linguistic signals. We choose these application areas as there is existing work that models these domains using HL-MRF models using manually defined rules that can serve as a comparison both quantitatively and qualitatively with our learned model structures [Zhang et al., 2018; Tomkins et al., 2018]. We compare the structure learned by A3SL with greedy structure learning algorithm (Greedy-SL), a combination of a path-based structure learning algorithm, hypergraph lifting [Kok and Domingos, 2009], with a feature selection based structure learning algorithm [Zhu et al., 2010] (Hypergraph Lifting with L1 regularization) and model designed by a human expert (human-expert), and logistic regression. Our Greedy-SL algorithm learns the clause structure from a list of predicates, whereas existing greedy structure learning for HL-MRFs [Embar et al., 2018] and inductive logic programming [Zeng et al., 2014] require a pre-defined set of clauses.

2. How well do our rules imbibe the desirable characteristics present in models designed by human experts? We compare the structure of the learned models using A3SL with model structures defined by human experts, both quantitatively and qualitatively, to demonstrate that our algorithm learns semantically meaningful structures that also are capable of achieving good prediction performance, thus combining the benefits of semantic coherence in human-defined clauses and performance-oriented data-driven clause structures.

4.1 Case 1: Modeling Recovery in AUD

To model recovery from AUD, we use the dataset in Zhang et al. [2018]. In this dataset, there are 302 users attending Alcoholics Anonymous (AA) labeled with recovery and relapse. For each of the AA-attending user, the dataset contains the most recent 3, 200 tweets for each of these users, containing a total of 274, 595 AA user tweets. For 302 AA users, there are 76, 183 friends in dataset. For each friend, the dataset contains 3, 200 tweets, containing a total of 14, 921, 997 tweets. We follow Zhang et al. [2018] to extract the same features to enable a direct comparison.

Table 1 shows the 5-fold cross-validation results on predicting recovery and relapse of AA-attending users. We observe that A3SL achieves a statistically significant prediction performance with a rejection threshold of p = 0.01 when compared with the manually specified model on the same dataset [Zhang et al., 2018], Greedy-SL, and a logistic regression baseline. Examining the learned structures qualitatively, we observe that A3SL learns a variety of different clauses, capturing the semantic domain-specific constraints of associating alcohol-related signals to relapse and sobriety-related signals to recovery, and also learning data-driven variations from explorations resulting in better prediction performance.

Tables 2 and 3 present a comparison of some representative clauses learned by A3SL with manually constructed ones. U refers to the AA-attending user that we want to predict recovery/relapse, U1 refers to friend of AA-user U, I refers to user post, I1 refers to friend post, and AW and SW refer to specific alcohol/sober word from a vocabulary of alcohol/sober words. We group the learned rules into two categories: i) local rules: rules that capture dependencies among features on the users to predict their recovery/relapse, and ii) network rules: rules that capture users' relationships with their friends to reason about the users' recovery/relapse. We find that A3SL learns semantically meaningful clauses containing multiple features of the same signal (set B) and both alcohol and sober signals (set C), thus appealing to domain experts as well as capturing uncertainty better. Similarly, A3SL learns a variety of network rules that combine linguistic features from users (usesSoberWord(U, SW)) with linguistic features from friends (friendContainsSoberWord(U1, I1, SW1)) and uses the network structure (friends(U, U1), friendRetweets(U1, U, I1)) to reason about recovery. A3SL's ability to learn these

Comparison of Network Rules learned from A3SL with human expert rules

D. Human Expert: Sample Network Rule

1. replies(U, U1, I) ∧ friendRetweets(U1, U, I1) ∧

friendContainsAlcoholWord(U1, I1, AW) →¬recovers(U)

E. A3SL: Similar to Human Expert

1. friendReplies(U1,U,I1) ∧ friendContainsSoberWord(U1, I1, SW)→recovers(U)

2. friends(U, U1) ∧ friendContainsAlcoholWord(U1, I1, AW) →¬recovers(U)

F. A3SL: Combines linguistic features from AA user's posts and friends' posts

1. friends(U, U1) ∧ usesSoberWord(U, SW) ∧ friendContainsSoberWord(U1, I1, SW) → recovers(U)
2. friends(U, U1) ∧¬termFrequency(U) ∧ usesAlcoholWord(U, AW)
3. ∧ friendContainsAlcoholWord(U1, I1, AW) →¬recovers(U)

Table 3: Comparison of network rules from HL-MRF Model designed by human expert and learned by A3SL

network dependencies makes it a powerful structure learning algorithm that brings out the modeling power of relational models.

4.2 Case 2: Detecting BullyingMessages

To learn a model for detecting bullying messages, we use the Formspring dataset. The dataset has a total of 13, 159 messages. We follow existing work on the dataset that uses HLMRFs to model bullying and construct similar feature predicates [Tomkins et al., 2018; Zhang and Ramesh, 2018] and consider a similar latent variable intensity(I) as in [Tomkins et al., 2018], indicating the extent of bullying in a post I. Note that ours is the first structure learning algorithm that is capable of learning meaningful latent variable dependencies and other existing work including our Greedy-SL algorithm is not capable of learning latent variables. Table 4 gives the comparison of performance of A3SL with Greedy-SL, manually defined rules inspired from Tomkins et al. [2018] and logistic regression baseline. We observe that A3SL not only performs the best (statistically significant, p = 0.05), but also learns meaningful latent variable associations (intensity with negative sentiment, negative and anonymity) as evident in Table 5. BW refers to the presence of a bullying word in the text. We can see that A3SL learns a variety of clauses: local rules, priors, containing different combinations of feature, latent variable, and target, abstracting the latent variable using a complex combination of features and target variables.

4.3 Grounding Coverage and Correlation of Latent Variables

When manually defining the structure of models such as HLMRFs, it is often challenging to define network rules that correspond to intuition and are also true in the data. For example, the manually-defined network rule in Table 3 captures that if the AA-user's friend uses alcohol words in a post and the AA-user retweets it, then that indicates that the user does not recover. From Figure 1(a), we observe that the average number of instances across all network rules in the human expert model is less than 30, indicating that the manually identified network rules may not be true in the data. On the other hand, we observe that the average groundings for the network rules learned by A3SL is approximately 200. Similarly, we observe that the network rules learned by A3SL have better data coverage, covering all the AA-user instances, while the manually defined network rules only cover a third of the instances. The human expert clauses have less overlap as humans intuitively tend to associate certain signals with recovery and others with relapse. But, A3SL clauses have superior overlap, allowing for representing the inherent uncertainty present in real-world data. Similarly, examining the correlation of the learned values of latent variable intensity with the target variable bullying in Figure 1(b), we find that it is consistently better correlated across the cross-validation folds, which indicates A3SL's capability to learn meaningful dependencies between features, latent and target variables.

Figure 1: Grounding coverage of network clauses in AA recovery prediction (left) and correlation of latent variables with target variables in bullying detection (right)

5 Conclusion

In this work, we presented a deep RL structure learning algorithm for HL-MRFs, A3SL, that asynchronously uses multiple actor-learners in parallel to explore different parts of the state space, thus possessing the capability to learn diverse models, while remaining scalable. Our algorithm has the capability to encode guidance from domain experts to learn models that are semantically meaningful without compromising on performance. Our experiments on two important computational social science applications demonstrate that A3SL can learn model structures that capture the salient modeling requirements of the domains.