Apertium has moved from SourceForge to GitHub.
If you have any questions, please come and talk to us on #apertium on irc.freenode.net or contact the GitHub migration team.

Anaphora Resolution Module

From Apertium
(Difference between revisions)
Jump to: navigation, search
(How does it work?)
(6 intermediate revisions by one user not shown)
Line 2: Line 2:
 
Here you will find the documentation for the Anaphora Resolution module created during the Google Summer of Code 2019. ([http://wiki.apertium.org/wiki/User:Khannatanmai Proposal])
 
Here you will find the documentation for the Anaphora Resolution module created during the Google Summer of Code 2019. ([http://wiki.apertium.org/wiki/User:Khannatanmai Proposal])
   
Repo: https://github.com/apertium/apertium-anaphora
+
Repo: https://github.com/apertium/apertium-anaphora (Final Module)
  +
  +
Repo: https://github.com/khannatanmai/apertium-anaphora (used during GSoC)
   
 
== What is Anaphora Resolution? ==
 
== What is Anaphora Resolution? ==
Line 16: Line 16:
 
For example,
 
For example,
   
'''Jessica''' is in the sixth grade and this is '''her''' father.
+
'''''Jessica''' is in the sixth grade and this is '''her''' father.''
   
 
Here, "her" is the anaphor, and its antecedent is "Jessica".
 
Here, "her" is the anaphor, and its antecedent is "Jessica".
Line 121: Line 121:
   
 
== How to Use ==
 
== How to Use ==
  +
First, clone the repo : https://github.com/apertium/apertium-anaphora and follow the instructions in the [https://github.com/apertium/apertium-anaphora/blob/master/README README] to install the module.
  +
  +
You can use the Anaphora Resolution module with your language pair in two steps: Creating an arx file for the Anaphora Module and modifying transfer rules (t1x). Here's how to do this:
  +
  +
=== Creating an arx file for a language pair ===
  +
<code>
  +
apertium-xxx-yyy.xxx-yyy.arx
  +
</code>
  +
  +
The Anaphora Resolution Module is language agnostic but any decent module which does this needs to be tailored to specific language pairs. That is the function of this file.
  +
  +
You will define language specific syntax to detect patterns for the antecedent indicators - Preposition Phrases, Indefinite Noun Phrases, etc. These are called markables in the arx file.
  +
  +
==== def-parameters ====
  +
  +
Here you define what the module will identify as anaphors and as antecedents. All antecedents will be given scores in the module and all anaphors will have an antecedent attached to them in the module's output.
  +
  +
You also define the delimiter here, which is the tag <sent> which marks the ends of sentences, which is used to keep a context of the current and last three sentences. Make sure this is defined in your arx file.
  +
  +
==== def-cats ====
  +
  +
Like transfer, here you define the categories that you're gonna use later to detect the patterns for the markables later.
  +
  +
==== def-markables ====
  +
  +
Here you define the markables and all the patterns that you want to be detected for each markable. For example, all the syntactic patterns that are Preposition Phrases.
  +
  +
With each markable you can also mention an integer as the score which will be used when calculating the scores.
  +
  +
If you put the score as -1, every antecedent which is a part of said markable gets a -1 score when the algorithm is calculating the final score to find the antecedent of an anaphor.
  +
  +
'''Example File: [Add Example Here]'''
  +
  +
=== Modifying Transfer Rules (t1x) ===
  +
  +
Once the antecedent is attached to an anaphor, we can modify it in transfer to produce the correct translation in the target language.
  +
  +
To do this, you can write a macro which changes the output based on the attached antecedent '''(side="ref")'''.
  +
  +
'''Example File: [Add Example Here]'''
  +
  +
Then, follow the instructions in the [https://github.com/apertium/apertium-anaphora/blob/master/README README] to run the module.

Revision as of 01:03, 12 August 2019

Here you will find the documentation for the Anaphora Resolution module created during the Google Summer of Code 2019. (Proposal)

Repo: https://github.com/apertium/apertium-anaphora (Final Module)

Repo: https://github.com/khannatanmai/apertium-anaphora (used during GSoC)

Contents

What is Anaphora Resolution?

Anaphora Resolution is the problem of resolving references to earlier items in discourse.

Anaphor: A linguistic unit that refers to an earlier linguistic unit in discourse.
Antecedent: The linguistic unit that the anaphor refers to.

The most common form of this is Pronominal Anaphora, where the anaphor is a pronoun and the antecedent is a noun.

For example,

Jessica is in the sixth grade and this is her father.

Here, "her" is the anaphor, and its antecedent is "Jessica".

Anaphora Resolution in Machine Translation

Anaphora Resolution is required in Machine Translation to produce correct and fluent translations. Since different languages encode information differently, resolving the antecedent of the anaphors in text becomes essential in several language pairs.

For example,

  • Spanish -> English
La chica comió su manzana
Translation: The girl ate his/her/its apple
Resolved Anaphora: The girl ate her apple
  • Add more examples

Anaphora Resolution in Apertium

Anaphora Resolution happens in two stages in the pipeline: In the Anaphora Resolution module and the in the Transfer stage.

We find the antecedent and attach it to the anaphor in the Anaphora Resolution module and select the correct pronoun in the Transfer stage.

Anaphora Resolution Module

In the Apertium pipeline, Anaphora Resolution happens after the Lexical Selection module, right before Transfer.

The output from the Lexical Selection module is analysed, and for each anaphor, the context is processed and the perceived antecedent is attached to the Lexical Unit of the anaphor. It is then sent to Transfer.

If the input sentence is Els grups del Parlament han mostrat aquest dimarts el seu suport al batle d'Alaró

The input to the Anaphora Resolution Module is:

^El<det><def><m><pl>/The<det><def><m><pl>$ ^grup<n><m><pl>/group<n><pl>$ ^de<pr>/of<pr>/from<pr>$ 
^el<det><def><m><sg>/the<det><def><m><sg>$ ^Parlament<n><m><sg>/Parliament<n><sg>$ 
^haver<vbhaver><pri><p3><pl>/have<vbhaver><pri><p3><pl>$ 
^mostrar<vblex><pp><m><sg>/show<vblex><pp><m><sg>/display<vblex><pp><m><sg>$ 
^aquest<det><dem><m><sg>/this<det><dem><m><sg>$ ^dimarts<n><m><sp>/Tuesday<n><ND>$ 
^el seu<det><pos><m><sg>/his<det><pos><m><sg>$ ^suport<n><m><sg>/support<n><sg>$ 
^a<pr>/at<pr>/in<pr>/to<pr>$ ^el<det><def><m><sg>/the<det><def><m><sg>$ 
^*batle/*batle$ ^de<pr>/of<pr>/from<pr>$ ^*Alaró/*Alaró$^.<sent>/.<sent>$

The output is as follows:

^El<det><def><m><pl>/The<det><def><m><pl>/$ ^grup<n><m><pl>/group<n><pl>/$ ^de<pr>/of<pr>/from<pr>/$ 
^el<det><def><m><sg>/the<det><def><m><sg>/$ ^Parlament<n><m><sg>/Parliament<n><sg>/$ 
^haver<vbhaver><pri><p3><pl>/have<vbhaver><pri><p3><pl>/$ 
^mostrar<vblex><pp><m><sg>/show<vblex><pp><m><sg>/display<vblex><pp><m><sg>/$ 
^aquest<det><dem><m><sg>/this<det><dem><m><sg>/$ ^dimarts<n><m><sp>/Tuesday<n><ND>/$ 
^el seu<det><pos><m><sg>/his<det><pos><m><sg>/group<n><pl>$ ^suport<n><m><sg>/support<n><sg>/$ 
^a<pr>/at<pr>/in<pr>/to<pr>/$ ^el<det><def><m><sg>/the<det><def><m><sg>/$ 
^*batle/*batle/$ ^de<pr>/of<pr>/from<pr>/$ ^*Alaró/*Alaró/$^.<sent>/.<sent>/$

So we can see that the anaphor el seu (a possessive determiner)

^el seu<det><pos><m><sg>/his<det><pos><m><sg>$

gets modified to

^el seu<det><pos><m><sg>/his<det><pos><m><sg>/group<n><pl>$

as we attach its antecedent group to it.

This is then passed on to Transfer.

Transfer

Since originally Apertium didn't deal with Anaphora Resolution, it used to put a default translation - "his" in the above example.

Now, the Anaphora Resolution Module attaches its antecedent in the LU, which we can use to change it to the correct anaphor using a macro in the transfer rules of the language pair. (t1x)

These rules represent logic similar to:

  • if antecedent is plural, change his to their.
  • if antecedent is female, change his to her.

How does it work?

Anaphora Resolution is usually done either using Parse Trees, or using Machine Learning. However, to obtain accurate Parse Trees or accurate results from an ML algorithm, one needs a lot of data.

However, Apertium is a system which deals largely with Low Resource languages and hence parse trees aren't available during translation and the language pairs usually don't have enough parallel data to train ML algorithms that give accurate results.

The Algorithm we use to resolve Anaphora in this module is a method which doesn't use parse trees or any data to train. It uses saliency scores to select an antecedent in the context.

Mitkov's Antecedent Indicators

In this algorithm, every time we encounter an anaphor, we collect a list of all possible antecedents in the current sentence and the last 3 sentences.

Then using some indicators, we give each potential antecedent a positive or a negative score. These indicators are chosen based on a knowledge of the language pair and statistical analysis.

Some of these indicators could be language pair specific and hence it is completely customisable, using the .arx files.

Here are some common indicators:

Boosting Indicators (given a positive score)

  • First NPs
  • Referential Distance: Potential antecedents closer to the anaphor are given are more likely to be the antecedent.

Impeding Indicators (given a negative score)

  • Indefiniteness: Indefinite NPs are penalised
  • Prepositional NPs: NPs which are part of a PP are penalised.

After this is done, the highest scored potential antecedent is chosen as the final antecedent and attached to the anaphor.

Reference : Multilingual Anaphora Resolution, Ruslan Mitkov

How to Use

First, clone the repo : https://github.com/apertium/apertium-anaphora and follow the instructions in the README to install the module.

You can use the Anaphora Resolution module with your language pair in two steps: Creating an arx file for the Anaphora Module and modifying transfer rules (t1x). Here's how to do this:

Creating an arx file for a language pair

apertium-xxx-yyy.xxx-yyy.arx

The Anaphora Resolution Module is language agnostic but any decent module which does this needs to be tailored to specific language pairs. That is the function of this file.

You will define language specific syntax to detect patterns for the antecedent indicators - Preposition Phrases, Indefinite Noun Phrases, etc. These are called markables in the arx file.

def-parameters

Here you define what the module will identify as anaphors and as antecedents. All antecedents will be given scores in the module and all anaphors will have an antecedent attached to them in the module's output.

You also define the delimiter here, which is the tag <sent> which marks the ends of sentences, which is used to keep a context of the current and last three sentences. Make sure this is defined in your arx file.

def-cats

Like transfer, here you define the categories that you're gonna use later to detect the patterns for the markables later.

def-markables

Here you define the markables and all the patterns that you want to be detected for each markable. For example, all the syntactic patterns that are Preposition Phrases.

With each markable you can also mention an integer as the score which will be used when calculating the scores.

If you put the score as -1, every antecedent which is a part of said markable gets a -1 score when the algorithm is calculating the final score to find the antecedent of an anaphor.

Example File: [Add Example Here]

Modifying Transfer Rules (t1x)

Once the antecedent is attached to an anaphor, we can modify it in transfer to produce the correct translation in the target language.

To do this, you can write a macro which changes the output based on the attached antecedent (side="ref").

Example File: [Add Example Here]

Then, follow the instructions in the README to run the module.

Personal tools