Joint Entity and Event Extraction with Generative Adversarial Imitation Learning

We propose a new framework for entity and event extraction based on generative adversarial imitation learning—an inverse reinforcement learning method using a generative adversarial network (GAN). We assume that instances and labels yield to various extents of difficulty and the gains and penalties (rewards) are expected to be diverse. We utilize discriminators to estimate proper rewards according to the difference between the labels committed by the ground-truth (expert) and the extractor (agent). Our experiments demonstrate that the proposed framework outperforms state-of-the-art methods.


INTRODUCTION
Event extraction (EE) is a crucial information extraction (IE) task that focuses on extracting structured information (i.e., a structure of event trigger and arguments, "what is happening", and "who or what is involved") from unstructured texts.For example, in the sentence "Masih's alleged comments of blasphemy are punishable by death under Pakistan Penal Code" shown in Figure 1, there is a Sentence event ("punishable"), and an Execute event ("death") involving the person entity "Masih".Most event extraction research has been in the context of the 2005 National Institute of Standards and Technology (NIST) Automatic Content Extraction (ACE) sentence-level event mention task [1], which also provides the standard corpus.The annotation guidelines of the ACE program define an event as a specific occurrence of something that happens involving participants, often described as a change of state [2].More recently, the NIST Text Such a mistake is due to the lack of a mechanism that explicitly deals with wrong and confusing labels.Many multi-classification approaches utilize cross-entropy loss, which aims at boosting the probability of the correct labels, and usually treats wrong labels equally and merely inhibits them indirectly.Models are trained to capture features and weights to pursue correct labels, but will become vulnerable and unable to avoid mistakes when facing ambiguous instances, where the probabilities of the confusing and wrong labels are not sufficiently "suppressed".Therefore, exploring information from wrong labels is a key to make the models robust.Our framework includes a reward estimator based on a generative adversarial network (GAN) to issue dynamic rewards with regard to the labels (actions) committed by event extractor (agent).The reward estimator is trained upon the difference between the labels from ground truth (expert) and extractor (agent).If the extractor repeatedly misses Execute label for "death", the penalty (negative reward values) is strengthened; if the extractor makes surprising mistakes: label "death" as Person or label Person "Masih" as Place role in Sentence event, the penalty is also strong.For cases where extractor is correct, simpler cases such as Sentence on "death" will take a smaller gain while diffi cult cases Execute on "death" will be awarded with larger reward values.

Joint Entity and Event Extraction with Generative Adversarial Imitation Learning
In this paper, to combat the problems of previous approaches toward this task, we propose a dynamic mechanism-inverse reinforcement learning-to directly assess correct and wrong labels on instances in entity and event extraction.We assign explicit scores on cases-or rewards in terms of Reinforcement Learning (RL).We adopt discriminators from a generative adversarial network (GAN) to estimate the reward values.Discriminators ensure the highest reward for ground-truth (expert) and the extractor attempts to imitate the expert by pursuing highest rewards.For challenging cases, if the extractor continues selecting wrong labels, the GAN keeps expanding the margins between rewards for ground-truth labels and (wrong) extractor labels and eventually deviates the extractor from wrong labels.
The main contributions of this paper can be summarized as follows: • We apply RL framework to event extraction tasks, and the proposed framework is an end-to-end and pipelined approach that extracts entities and event triggers and determines the argument roles for detected entities.• With inverse RL propelled by the GAN, we demonstrate that a dynamic reward function ensures more optimal performance in a complicated RL task.

R ELATED WORK
One of the recent event extraction approaches mentioned in the introductory section [18] utilizes the GAN in event extraction.The GAN in the cited work outputs generated features to regulate the event model from features leading to errors, while our approach directly assesses the mistakes to explore levels of difficulty in labels.Moreover, our approach also covers argument role labeling, while the cited paper does not.
RL-based methods have been recently applied to a few information extraction tasks such as relation extraction, and both relation frameworks from [21,22] apply RL on entity relation detection with a series of predefined rewards.
We are aware that the term imitation learning is slightly different from inverse reinforcement learning.Techniques of imitation learning [23,24,25] attempt to map the states to expert actions by following demonstration, which resembles supervised learning, while inverse RL [26,27,28,29,30] estimates the rewards first and applies the rewards to RL. [31] is an imitation learning application on bio-medical event extraction, and there is no reward estimator used.We humbly recognize our work as inverse reinforcement learning approach although "Generative Adversarial Imitation Learning" (GAIL) is named after imitation learning.

T ASK AND TERM PRELIMINARIES
In this paper we follow the schema of Automatic Content Extraction (ACE) [1] to detect the following elements from unstructured natural language data: • Entity: Word or phrase that describes a real world object such as a person ("Masih" as PER in Figure 1).ACE schema defines seven types of entities.• Event trigger: The word that most clearly expresses an event (interaction or change of status).ACE schema defines 33 types of events such as Sentence ("punishable" in Figure 1) and Execute ("death").• Event argument: An entity that serves as a participant or attribute with a specific role in an event mention, in Figure 1 e.g., a PER "Masih" serves as a Defendant in a Sentence event triggered by "punishable".
The ACE schema also comes with a data set-ACE2005  -which has been used as a benchmark for information extraction frameworks and we will introduce this data set in Section 6.
For broader readers who might not be familiar with RL, we briefly introduce their counterparts or equivalent concepts in supervised models with the RL terms in the parentheses: our goal is to train an extractor (agent A) to label entities, event triggers and argument roles (actions a) in text (environment e); to commit correct labels, the extractor consumes features (state s) and follows the ground truth (expert E); a reward R will be issued to the extractor according to whether it is different from the ground truth and how serious the difference is-as shown in Figure 1, a repeated mistake is definitely more serious-and the extractor improves the extraction model (policy π) by pursuing maximized rewards.
Our framework can be briefly described as follows: given a sentence, our extractor scans the sentence and determines the boundaries and types of entities and event triggers using Q-Learning (Section 4.1); meanwhile, the extractor determines the relations between triggers and entities-argument roles with policy gradient (Section 4.2).During the training epochs, GANs estimate rewards which stimulate the extractor to pursue the most optimal joint model (Section 5).

Q-L earning for Entities and Triggers
The entity and trigger detection is often modeled as a sequence labeling problem, where long-term dependency is a core nature; and RL is a well-suited method [32].
From RL perspective, our extractor (agent A) is exploring the environment, or unstructured natural language sentences when going through the sequences and committing labels (actions a) for the tokens.When the extractor arrives at the tth token in the sentence, it observes information from the environment and its previous action a t-1 as its current state s t ; when the extractor commits a current action a t and moves to the next token, it has a new state s t+1 .The information from the environment is the token's context embedding v t , which is usually acquired from Bidirectional Long Short-Term Memory (Bi-LSTM) [33]  https://catalog.ldc.upenn.edu/LDC2006T06

Joint Entity and Event Extraction with Generative Adversarial Imitation Learning
outputs; previous action a t-1 may impose some constraint for current action a t , e.g., I-ORG does not follow B-PER  .With the aforementioned notations, we have 1 =< , > .
To determine the current action a t , we generate a series of Q-Tables with   1  2  1  2 ( , ) = ( | , , , , , ), where f sl (•) denotes a function that determines the Q-values using the current state as well as previous states and actions.Then we achieve ˆarg max = ( , ) .
Equations ( 2) and ( 3) suggest that a Recurrent Neural Network (RNN)-based framework which consumes current input and previous inputs and outputs can be adopted, and we use a unidirectional LSTM as [34].We have a full pipeline as illustrated in Figure 2.
For each label (action a t ) with regard to s t , a reward r t = r(s t , a t ) is assigned to the extractor (agent).We use Q-Learning to pursue the most optimal sequence labeling model (policy π) by maximizing the expected value of the sum of future rewards E(R t ), where R t represents the sum of discounted future rewards r t + cr t+1 + c 2 r t+2 +… with a discount factor c, which determines the influence between current and next states.
We utilize Bellman Equation to update the Q-value with regard to the current assigned label to approximate an optimal model (policy π*): As illustrated in Figure 3, when the extractor assigns a wrong label on the "death" token because the Q-value of Die ranks first, Equation (4) will penalize the Q-value with regard to the wrong label; while in later epochs, if the extractor commits a correct label of Execute, the Q-value will be boosted and make the decision reinforced.
We minimize the loss in terms of mean squared error between the original and updated Q-values notated as ( , ) and apply back propagation to optimize the parameters in the neural network.
 In this work, we use BIO, e.g., "B-Meet" indicates the token is beginning of Meet trigger, "I-ORG" means that the token is inside an organization phrase, and "O" denotes null.4), with fi xed rewards r = ±5 for correct/ wrong labels and discount factor l = 0.01.Score for a wrong label is penalized while correct one is reinforced.

Policy Gradient for Argu ment Roles
After the extractor determines the entities and triggers, it takes pairs of one trigger and one entity (argument candidate) to determine whether the latter serves a role in the event triggered by the former.

Joint Entity and Event Extraction with Generative Adversarial Imitation Learning
In this task, for each pair of trigger and argument candidate, our extractor observes the context embeddings of trigger and argument candidate-v ttr and v tar , respectively, as well as the output of another Bi-LSTM consuming the sequence of context embeddings between trigger and argument candidates in the state; the state also includes a representation (one-hot vector) of the entity type of the argument candidate a tar , and the event type of the trigger a tar also determines the available argument role labels, e.g., an Attack event never has Adjudicator arguments as Sentence events.With these notations we have: , = < , , , , >, We assign a reward r(s tr,ar , a tr,ar ) to the extractor, and since there is one step in determining the argument role label, the expected values of R = r(s tr,ar , a tr,ar ).
We utilize another RL algorithm-Policy Gradient [36] to pursue the most optimal argument role labeling performance.
We have probability distribution of argument role labels that are from the softmax output of Q-values: From Equation (10) and Figure 4 we acknowledge that, when the extractor commits a correct label (Agent for the GPE entity "Pakistan"), the reward encourages P(a tr,ar |s tr,ar ) to increase; and when the extractor is wrong (e.g., Place for "Pakistan"), the reward will be negative, leading to a decreased P(a tr,ar |s tr,ar ).

Choice of Algorithms
Here we have a brief clarification on different choices of RL algorithms in the two tasks.
In the sequence labeling task, we do not take policy gradient approach due to high variance of E(R t ), i.e., the sum of future rewards R t should be negative when the extractor chooses a wrong label, but an illset reward and discount factor c assignment or estimation may give a positive R t (often with a small value) and still push up the probability of the wrong action, which is not desired.There are some variance reduction approaches to constraining the R t but they still need additional estimation and bad estimation will introduce new risks.Q-Learning only requires rewards on current actions r t , which are relatively easy to constrain.
In the argument role labeling task, determination on each trigger-entity pair consists of only one single step and R t is exactly the current reward r, and then policy gradient approach performs correctly if we ensure negative rewards for wrong actions and positive for correct ones.However, this one-step property impacts the Q-Learning approach: without new positive values from further steps, a small positive reward on current correct labels may make the updated Q-value smaller than those wrong ones.This strategy makes the RL-based approach no difference from classification approaches with crossentropy in terms of "treating wrong labels equally" as discussed in the introductory section.Moreover, recent RL approaches on relation extraction [21,22] adopt a fixed setting of reward values with regard to different phases of entity and relation detection based on empirical tuning, which requires additional tuning work when switching to another data set or schema.
In event extraction task, entity, event and argument role labels yield to a complex structure with variant difficulties.Errors should be evaluated case by case, and from epoch to epoch.In the earlier epochs, when parameters in the neural networks are slightly optimized, all errors are tolerable, e.g., in sequence labeling, extractor within the first two or three iterations usually labels most tokens with O labels.As the epoch number increases, the extractor is expected to output more correct labels; however, if the extractor makes repeated mistakes-e.g., the extractor persistently labels "death" as O in the example sentence "... are punishable by death ..." during multiple epochs-or is stuck in difficult cases-e.g., whether FAC (facility) token "bridges" serves as a Place or Target role in an Attack event triggered by "bombed" in sentence "US aircraft bombed Iraqi tanks holding bridges..."-a mechanism is required to assess these challenges and to correct them with salient and dynamic rewards.
We describe the training approach as a process of extractor (agent A) imitating the ground-truth (expert E), and during the process, a mechanism ensures that the highest reward values are issued to correct labels (actions a), including the ones from both expert E and a: This mechanism is Inverse Reinforcement Learning [26], which estimates the reward first in an RL framework.
Equation ( 12) reveals a scenario of adversary between ground truth and extractor and GAIL [29], which is based on GAN [37], fits such adversarial nature.
In the original GAN, a generator generates (fake) data and attempts to confuse a discriminator D which is trained to distinguish fake data from real data.In our proposed GAIL framework, the extractor (agent A) substitutes the generator and commits labels to the discriminator D; the discriminator D, now serves as reward estimator, aims to issue largest rewards to labels (actions) from the ground-truth (expert E) or identical ones from the extractor but provides lower rewards for other/wrong labels.

Joint Entity and Event Extraction with Generative Adversarial Imitation Learning
Rewards R(s,a) and the output of D are now equivalent and we ensure: where s, a E and a A are inputs of the discriminator.In the sequence labeling task, s consists of the context embedding of current token v t and a one-hot vector that represents the previous action a t-1 according to Equation (1), and in the argument role labeling task, s comes from the representations of all elements mentioned in Equation ( 6); a E is a one-hot vector of ground-truth label (expert, or "real data") while a A denotes the counterpart from the extractor (agent, or "generator").The concatenated s and a E is the input for "real data" channel while s and a A build the input for "generator" channel of the discriminator.
In our framework, due to the different dimensions in the two tasks and event types, we have 34 discriminators (one for sequence labeling, and 33 for event argument role labeling with regard to 33 event types).Every discriminator consists of two fully-connected layers with a sigmoid output.The original output of D denotes a probability which is bounded in [0,1], and we use linear transformation to shift and expand it: e.g., in our experiments, we set a = 20 and b = 0.5 and make ( , ) [ 10,10] R s a ∈ − .
To pursue Equation ( 13), we minimize the loss function and optimize the parameters in the neural network: During the training process, after we feed the neural network mentioned in Section 4.1 and 4.2 with a mini-batch of the data, we collect the features (or states s), corresponding extractor labels (agent actions a A ) and ground-truth (expert actions a E ) to update the discriminators according to Equation ( 15); then we feed features and extractor labels into the discriminators to acquire reward values and train the extractoror the generator from the GAN's perspective.
Since the discriminators are continuously optimized, if the extractor (generator) makes repeated mistakes or makes surprising ones (e.g., considering a PER as a Place), the margin of rewards between correct and wrong labels expands and outputs reward with larger absolute values.Hence, in sequence labeling task, the updated Q-values are updated with a more discriminative difference, and, similarly, in argument role labeling task, the P(a|s) also increases or decreases more significantly with a larger absolute reward value.An illustrative example of the GAN structure in sequence labeling scenario (argument role labeling scenario has the identical frameworks except vector dimensions).As introduced in Section 5, the "real data" in the original GAN is replaced by feature/state representation (Equation (1), or Equation ( 6) for argument role labeling scenario) and ground-truth labels (expert actions) in our framework, while the "generator data" consists of features and extractor's attempt labels (agent actions).The discriminator serves as the reward estimator and a linear transform is utilized to extend the D's original output of probability range [0,1].
In case where discriminators are not sufficiently optimized (e.g., in early epochs) and may output undesired values-e.g., negative for correct actions, we impose a hard margin: ( to ensure that correct actions will always take positive reward values and wrong ones take negative.

EXPLORA TION
In training phase, the extractor selects labels according to the rankings of Q-values in Equations ( 3) and ( 8) and GANs will issue rewards to update the Q-Tables and policy probabilities; and we also adopt e-greedy strategy: we set a probability threshold [0,1) e ∈ and uniformly sample a number [0,1] ∈ r before the extractor commits a label for an instance: With this strategy, the extractor is able to explore all possible labels (including correct and wrong ones), and acquires rewards with regard to all labels to update the neural networks with richer information.
Moreover, after one step of e-greedy exploration, we also force the extractor to commit ground-truth labels and issue it with expert (highest) rewards, and update the parameters accordingly.This additional step is inspired by [38,39], which combines cross-entropy loss from supervised models with RL loss functions  .Such combination can simultaneously and explicitly encourage correct labels and penalize wrong labels and greatly improve the efficiency of pursuing optimal models. We do not directly adopt this because we treat cross-entropy loss as fixed rewards with r = 1 for correct label and r = 0 for wrong label but we prioritize the dynamic rewards.

Experiment S etup
To evaluate the performance with our proposed approach, we utilize ACE2005 documents.To align with state-of-the-art frameworks such as [13,16], we exclude informal documents from Conversational Telephone Speech (cts) and UseNet (un), and the rest of the documents include newswire (nw), weblogs (wl), broadcast news (bn) and broadcast conversations (bc) crawled between 2003 and 2005 and fully annonotated with 5,272 triggers and 9,612 arguments.To ensure fair comparison with the state-of-the-art methods, we follow the splits of training (529 documents with 14,180 sentences), validation (30 documents with 863 sentences) and test (40 documents with 672 sentences) data and adopt the same criteria of the evaluation: • An entity (named entities and nominals) is correct if its entity type and offsets find a match in the ground truth.• A trigger is correct if its event type and offsets find a match in the ground truth.
• An argument is correctly labeled if its event type, offsets and role find a match in the ground truth.
• All the aforementioned elements are evaluated using precision (denoted as P in the tables, the ratio of correct instances in the system result), recall (denoted as R in the tables, the ratio of correct system results in the ground-truth annotation) and F1 scores (denoted as F1, harmonic average of the precision and recall).
We use ELMo embeddings  [35].Because ELMo is delivered with built-in Bi-LSTMs, we treat ELMo embedding as context embeddings in Figures 2 and 4. We use GAIL-ELMo in the tables to denote the setting.
Moreover, in order to disentangle the contribution from ELMo embeddings, we also present the performance in a non-ELMo setting (denoted as GAIL-W2V) which utilizes the following embedding techniques to represent tokens in the input sentence.
• Token surface embeddings: For each unique token in the training set, we have a look-up dictionary for embeddings which is randomly initialized and updated in the training phase.• Character-based embeddings: Each character also has a randomly initialized embedding, and will be fed into a token-level Bi-LSTM network, and the final output of this network will enrich the information of tokens.• POS embeddings: We apply Part-of-Speech (POS) tagging on the sentences using Stanford CoreNLP tool [40].The POS tags of the tokens also have a trainable look-up dictionary (embeddings).• Pre-trained embeddings: We also acquire embeddings trained from a large and publicly available corpus.These embeddings preserve semantic information of the tokens and they are not updated in the training phase.

Event Extraction Performance
For event extraction performance with system-predicted entities as argument candidates, besides [42] and [6] we compare our performance with: • dbRNN [16]: an LSTM framework incorporating the dependency graph (dependency-bridge) information to detect event triggers and argument roles.
Table 2 demonstrates that the performance of our proposed framework is better than state-of-the-art approaches except lower F1 score on argument identification against [16].[16] utilizes Stanford CoreNLP to detect the noun phrases and take the detected phrases as argument candidates, while our argument candidates come from system predicted entities and some entities may be missed.However, [16]'s approach misses entity type information, which causes many errors in argument role labeling task, whereas our argument candidates hold entity types, and our final role labeling performance is better than [16].
Our framework is also flexible to consume ground-truth (gold) annotation of entities as argument candidates.And we demonstrate the performance comparison with the following state-of-the-art approaches on the same setting besides [16]: • JointIE-GT [4]: similar to [42], the only difference is that this approach detects arguments based on ground-truth entities.• JRNN [13], an RNN-based approach which integrates local lexical features.

Joint Entity and Event Extraction with Generative Adversarial Imitation Learning
For the instances with ambiguity, our dynamic reward function can provide more salient margins between correct and wrong labels.With the identical parameter set as aforementioned, reward for the wrong Die label is as lower as -8.27 while correct Execute label gains as high as 9.35. Figure 6 illustrates the curves of rewards with regard to epoch numbers.For easier instances, e.g., the trigger word "arrested" in "... police have arrested ..." have flatter reward values as 1.24 for Arrest-Jail, -1.53 for None or -1.37 for Attack, which are sufficient for correct labels.

Impact from Pretrained Embeddings
Scores in Tables 1, 2 and 3 prove that non-ELMo settings already outperform state-of-the-art, which confirms the advantage and contribution of our GAIL framework.Moreover, in spite of insignificant drop in fixed reward setting, we agree that ELMo is a good replacement for a combination of word, character and POS embeddings.The only shortcoming according to our empirical practice is that ELMo takes huge amount of GPU memory and the training procedure is slow (even we do not update the pre-trained parameters during our training phase).

Remain ing Errors
Losses of scores are mainly missed trigger words and arguments.For instance, the End-Position trigger "sack" is missed because it is considered informal to use the word to express an End-Position event, and there are no similar tokens in the training data or in pre-trained embeddings.Another example of error is due to informal expression, e.g., "I miss him to death", where the "death" does not trigger any event, while our system makes a mistake by detecting it as a Die event.Since most training sentences are formal writing, expression from oral speeches which are usually informal may cause errors.

Joint Entity and Event Extraction with Generative Adversarial Imitation Learning
Dr. Avirup Sil is a Research Scientist in the Information Extraction and natural language processing (NLP) group at IBM Research AI.He is also the Chair of the NLP professional community of IBM.Currently, he is working on industry scale NLP and deep learning algorithms.His work is mainly on information extraction: entity recognition and linking and relation extraction.Currently, he is working on Question Answering algorithms by attaching world knowledge to systems.He is a senior program committee member for major Computational Linguistics conferences including being an Area Chair multiple times.Avirup finished his PhD in Computer Science under the supervision of his thesis advisor Alexander Yates.He also worked on temporal information extraction in the Machine Learning Group at Microsoft Research, Redmond, managed by Chris Burges and John Platt.His mentor was Silviu Cucerzan.He has more than 12 US patents filed all in the area of artificial intelligence and its applications in various spheres.

Figure 1 .
Figure 1.Our framework includes a reward estimator based on a generative adversarial network (GAN) to issue dynamic rewards with regard to the labels (actions) committed by event extractor (agent).The reward estimator is trained upon the difference between the labels from ground truth (expert) and extractor (agent).If the extractor repeatedly misses Execute label for "death", the penalty (negative reward values) is strengthened; if the extractor makes surprising mistakes: label "death" as Person or label Person "Masih" as Place role in Sentence event, the penalty is also strong.For cases where extractor is correct, simpler cases such as Sentence on "death" will take a smaller gain while diffi cult cases Execute on "death" will be awarded with larger reward values.

Figure 2 .
Figure 2. A pipeline from input sentence to sequence labels mentioned in Section 4.1.Q-Tableandvalues for each current step is calculated using the unidirectional LSTM based on context embeddings of current and previous tokens as well as Q-Tables and values from previous steps.Context embeddings are calculated using Bi-LSTM from local token embeddings.Pre-trained embeddings based on Bi-LSTM such as ELMo[35] are also good candidates for context embeddings.

Figure 3 .
Figure 3.An illustrative example of updating the Q-values with Equation (4), with fi xed rewards r = ±5 for correct/ wrong labels and discount factor l = 0.01.Score for a wrong label is penalized while correct one is reinforced.

Figure 4 .
Figure 4.The extractor combines context embeddings of the trigger and entity, as well as a one-hot vector that represents entity type and Bi-LSTM output of sub-sentence between the trigger and argument.The column "trend" denotes the changes of P(a tr,ar |s tr,ar ) after policy gradient optimization in Equation(10).
Downloaded from http://direct.mit.edu/dint/article-pdf/1/2/99/1476706/dint_a_00014.pdf by guest on 18 August 2021 Data Intelligence 107 Joint Entity and Event Extraction with Generative Adversarial Imitation Learning 5. GENERATIVE ADVERSARIAL IMITATION LEA RNING So far in our paper, the reward values demonstrated in the examples are fixed, we have have c 1 > c 2 .

Figure 5
Figure 5 illustrates how we utilize a GAN for reward estimation.

Figure 5 .
Figure 5.An illustrative example of the GAN structure in sequence labeling scenario (argument role labeling scenario has the identical frameworks except vector dimensions).As introduced in Section 5, the "real data" in the original GAN is replaced by feature/state representation (Equation (1), or Equation (6) for argument role labeling scenario) and ground-truth labels (expert actions) in our framework, while the "generator data" consists of features and extractor's attempt labels (agent actions).The discriminator serves as the reward estimator and a linear transform is utilized to extend the D's original output of probability range [0,1].

Figure 6 .
Figure 6.Change of rewards with regard to event type labels on the trigger "death" mentioned in Figure 1.
where f tr,ar represents a mapping function whose output sizes are determined by the trigger event type a ttr , e.g., Attack event has five labels-Attacker, Target, Instrument, Place and Not-a-role and the mapping function for Attack event contains a fully-connected layer with output size of five.And we determine the role with Equation (8): Downloaded from http://direct.mit.edu/dint/article-pdf/1/2/99/1476706/dint_a_00014.pdf by guest on 18 August 2021