Dataset origin: https://lindat.mff.cuni.cz/repository/xmlui/handle/11234/1-3238

IWPT 2020 Shared Task on Parsing into Enhanced Universal Dependencies

This package contains data used in the IWPT 2020 shared task. The package is available from http://hdl.handle.net/11234/1-3238 (permanent URL).

For more information on the shared task, see the IWPT conference proceedings in the ACL anthology https://www.aclweb.org/anthology/sigs/sigparse/ as well as the shared task web site: https://universaldependencies.org/iwpt20/

The package contains training, development and test (evaluation) datasets as they were used during the shared task. The data is based on a subset of Universal Dependencies release 2.5 (http://hdl.handle.net/11234/1-3105) but some treebanks contain additional enhanced annotations. Moreover, not all of these additions became part of Universal Dependencies release 2.6 (http://hdl.handle.net/11234/1-3226), which makes the shared task data unique and worth a separate release to enable later comparison with new parsing algorithms.

LICENSE

The package is distributed under the same license as Universal Dependencies 2.5. This is a collective license, i.e., individual treebanks may use different license terms. See https://lindat.mff.cuni.cz/repository/xmlui/page/licence-UD-2.5?locale-attribute=en for details.

FILES AND FOLDERS

There are 17 languages and 28 treebanks. Some treebanks contain training, development and test data. Some treebanks contain only the test data. Each treebank has a folder named UD_Language-TreebankID:

UD_Arabic-PADT UD_Bulgarian-BTB UD_Czech-CAC UD_Czech-FicTree UD_Czech-PDT UD_Czech-PUD UD_Dutch-Alpino UD_Dutch-LassySmall UD_English-EWT UD_English-PUD UD_Estonian-EDT UD_Estonian-EWT UD_Finnish-PUD UD_Finnish-TDT UD_French-FQB UD_French-Sequoia UD_Italian-ISDT UD_Latvian-LVTB UD_Lithuanian-ALKSNIS UD_Polish-LFG UD_Polish-PDB UD_Polish-PUD UD_Russian-SynTagRus UD_Slovak-SNK UD_Swedish-PUD UD_Swedish-Talbanken UD_Tamil-TTB UD_Ukrainian-IU

Each folder contains one or more CoNLL-U files with gold-standard annotation following the UD guidelines (https://universaldependencies.org/guidelines.html), and one or more corresponding plain text files (the parsing systems get these files as input and produce parsed CoNLL-U files on output).

During the shared task, only the training and development portions were distributed in this form. The test data was distributed blind, i.e., only the plain text input without annotation. Moreover, test sets from all treebanks of one language were merged in one file and the participants were not told which part of the text comes from which treebank. In this package, we add four folders:

test-blind test-gold dev-blind dev-gold

The *-blind folders contain 17 text files each, named using language codes:

ar.txt (Arabic) bg.txt (Bulgarian) cs.txt (Czech) en.txt (English) et.txt (Estonian) fi.txt (Finnish) fr.txt (French) it.txt (Italian) lt.txt (Lithuanian) lv.txt (Latvian) nl.txt (Dutch) pl.txt (Polish) ru.txt (Russian) sk.txt (Slovak) sv.txt (Swedish) ta.txt (Tamil) uk.txt (Ukrainian)

The *-gold folders contain the corresponding gold-standard annotated files in two flavors: the real UD-compliant annotation, e.g., ar.conllu, and a file where empty nodes have been collapsed to make evaluation possible, e.g. ar.nen.conllu (nen = no empty nodes). In addition to the test files, we also provide the development files in the same form (they were also available to the participants of the shared task).

FRENCH

In addition to enhancements described in the UD v2 guidelines (https://universaldependencies.org/u/overview/enhanced-syntax.html), the French data also show neutralized diathesis in the spirit of (Candito et al. 2017). It is not possible to squeeze this information into the dependency labels in a way that would be both human-readable and valid according to the UD guidelines. Therefore, the French CoNLL-U files are provided in two flavors: "fulldeps" and "xoxdeps". The former is the intended, human- readable format where final and canonical grammatical functions are separated by the "@" character; e.g., "obl:agent@nsubj" means that the dependent is an oblique agent phrase (the final function) but canonically it corresponds to the subject of the verb in active form (the canonical function). Such dependency labels do not comply with the current UD guidelines which do not allow the "@" character in dependency labels (also, the full labels sometimes contain more colons ":" than permitted). The labels thus have been transformed reducing the number of colons and replacing "@" with "xox", hence the xoxdeps.conllu files. The systems participating in the shared task worked with the xoxdeps files, as these pass the official validation. However, the cryptic xoxdeps labels can be easily converted back to the original format, even in the parser output (provided the parser predicted the label correctly; see the tools below).

TOOLS

The package also contains a number of Perl and Python scripts that have been used to process the data during preparation and during the shared task. They are in the "tools" folder.

validate.py

The official Universal Dependencies validator. It is a Python 3 script, and it needs the third-party module regex to be installed on the system (use pip to install it). The script recognizes several levels of validity; system output in the shared task must be valid on level 2:

python validate.py --level 2 --lang ud file.conllu

enhanced_collapse_empty_nodes.pl

Removes empty nodes from a CoNLL-U file and transforms all paths traversing an empty node into a long edge with a combined label, e.g., "conj>nsubj". Note that the output is not valid according to UD guidelines, as the ">" character cannot occur in a normal CoNLL-U file. After passing validation, system outputs and gold-standard files are processed with this script and then they can be evaluated (the evaluator cannot work with empty nodes directly).

perl enhanced_collapse_empty_nodes.pl file.conllu > file.nen.conllu

iwpt20_xud_eval.py

The official evaluation script in the shared task. It takes valid gold-standard and system-output file after these have been processed with enhanced_collapse_empty_nodes.pl. It also requires that the text of the gold standard and system output differ only in whitespace characters (tokenization) while all non-whitespace characters must be identical (no normalization is allowed).

python iwpt20_xud_eval.py -v gold.nen.conllu system.nen.conllu

The script can be told that certain types of enhancements should not be evaluated. This is done with treebanks where some enhancements are not annotated in the gold standard and we do not want to penalize the system for predicting the enhancement. For example,

--enhancements 156

means that gapping (1), relative clauses (5), and case-enhanced deprels (6) should be ignored.

conllu-quick-fix.pl

A Perl script that tries to make an invalid file valid by filling out UPOS tags if they are empty, fixing the format of morphological features etc. It can also make sure that every node in the enhanced graph is reachable from the virtual root node with id 0; however, this function is optional, as it modifies the system-output dependency structure, and the algorithm it uses is not optimal in terms of evaluation score.

perl conllu-quick-fix.pl input.conllu > output.conllu perl conllu-quick-fix.pl --connect-to-root input.conllu > output.conllu

conllu_to_text.pl

This script was used to generate the untokenized text files that serve as the input for the trained parsing system (the "blind" data). It takes the ISO 639-1 code of the language of the text (e.g., "--language en") because it works a bit differently with languages that use Chinese characters. The option was not needed for the present shared task, as there were no such languages.

perl conllu_to_text.pl --language xx file.conllu > file.txt

mergetest.pl

This script was used to merge the test data (both gold and blind) from multiple treebanks of one language. The test sets are essentially concatenated, but the script makes sure that there is a new document mark at the beginning of each gold CoNLL-U file, and between two text files there is an empty line. This increases the chance that the systems will break a sentence at this position and it will be possible to separate data from individual treebanks in the system output. The first argument of the script is the name of the target file, the remaining arguments are names of the source files (any number, but at least one). By default, the files are processed as text files. If the target file name ends in ".conllu", the files are processed as CoNLL-U files.

perl mergetest.pl nl.conllu UD_Dutch-Alpino/nl_alpino-ud-test.conllu UD_Dutch-LassySmall/nl_lassysmall-ud-test.conllu perl mergetest.pl nl.txt UD_Dutch-Alpino/nl_alpino-ud-test.txt UD_Dutch-LassySmall/nl_lassysmall-ud-test.txt

match_and_split_conllu_by_input_text.pl

This script reverses mergetest.pl, i.e., splits the system output for a language into smaller files corresponding to individual treebanks. This must be done if we want to evaluate each treebank with different settings, i.e., ignoring enhancements that are not gold-annotated in the treebank. The script takes the input text of one treebank and the CoNLL-U file that starts with annotation of the input text but possibly contains more annotation of other text. Two CoNLL-U files will be generated: the first one corresponds to the input text, the second one is the rest. Therefore, if the language consists of more than two treebanks, the script must be run multiple times. The script can handle sentences that cross the file boundary (nodes whose parents lie in the other file will be re-attached to some other parent). However, the script cannot handle situations where a token crosses the file boundary.

perl match_and_split_conllu_by_input_text.pl UD_Dutch-Alpino/nl_alpino-ud-test.txt nl.conllu nl_alpino.conllu nl_rest.conllu

evaluate_all.pl

This script takes one shared task submission (tgz archive with CoNLL-U files for individual languages), unpacks it, checks whether the files are valid and evaluates them. The script is provided as-is and it is not ready to be run outside the shared task submission site. Various paths are hard-coded in the source code! However, the code shows how the evaluation was done using the other tools described above.

perl evaluate_all.pl team_name submission_id dev|test

html_evaluation.pl

This script relies on the same fixed folder structure as evaluate_all.pl, and it, too, has a path hard-wired in the source code. It scans the evaluation logs produced by evaluate_all.pl and creates a HTML file with score tables for the submission.

perl html_evaluation.pl team_name submission_id dev|test

expand_edeps_in_french.pl

Takes a CoNLL-U file with the cryptic-but-ud-valid encoding of the French double relations, ("xoxdeps") and converts them back to the human-readable form ("fulldeps").

perl expand_edeps_in_french.pl fr.xoxdeps.conllu > fr.fulldeps.conllu

enhanced_graph_properties.pl

Reads a CoNLL-U file and collects statistics about the enhanced graphs found in the DEPS column. Some of the statistics target abstract graph-theoretical properties, others target properties specific to Enhanced Universal Dependencies. The script also tries to collect clues about individual enhancement types defined in UD (thus assessing whether the enhancement is annotated in the given dataset).

perl enhanced_graph_properties.pl file.conllu

SYSTEM OUTPUTS

The folder "sysoutputs" contains the official primary submission of each team participating in the shared task. The folder names are the lowercased team names as used at submission time; they slightly differ from the spelling used in the shared task overview paper:

TurkuNLP ....... turkunlp Orange ......... orange_deskin Emory NLP ...... emorynlp FASTPARSE ...... fastparse UNIPI .......... unipi ShanghaiTech ... shanghaitech_alibaba CLASP .......... clasp ADAPT .......... adapt Køpsala ........ koebsala RobertNLP ...... robertnlp

In addition, there are three baseline submissions generated by the shared task organizers and described on the shared task website and in the overview paper:

baseline1 ... gold basic trees copied as enhanced graphs baseline2 ... UDPipe-predicted basic trees copied as enhanced graphs baseline3 ... UDPipe predicted basic trees, then Stanford Enhancer created enhanced graphs from them

REFERENCES

Gosse Bouma, Djamé Seddah, Daniel Zeman (2020). Overview of the IWPT 2020 Shared Task on Parsing into Enhanced Universal Dependencies. In Proceedings of the 16th International Conference on Parsing Technologies and the IWPT 2020 Shared Task on Parsing into Enhanced Universal Dependencies, Seattle, WA, USA, ISBN 978-1-952148-11-8

Marie Candito, Bruno Guillaume, Guy Perrier, Djamé Seddah (2017). Enhanced UD Dependencies with Neutralized Diathesis Alternation. In Proceedings of the Fourth International Conference on Dependency Linguistics (Depling 2017), pages 42–53, Pisa, Italy, September 18–20 2017

Citation

 @misc{11234/1-3238,
 title = {{IWPT} 2020 Shared Task Data and System Outputs},
 author = {Zeman, Daniel and Bouma, Gosse and Seddah, Djam{\'e}},
 url = {http://hdl.handle.net/11234/1-3238},
 note = {{LINDAT}/{CLARIAH}-{CZ} digital library at the Institute of Formal and Applied Linguistics ({{\'U}FAL}), Faculty of Mathematics and Physics, Charles University},
 copyright = {Licence Universal Dependencies v2.5},
 year = {2020} }