Material associated with the paper:

"A Parser for the Efficient Induction of Biological Grammars"

Paper reference

Authors: C.H. Bryant and D. Fredouille
Title: A Parser for the Efficient Induction of Biological Grammars
Conference: 15th International Conference on Inductive Logic Programming, 2005
Conference web: http://ilp2005.in.tum.de/
Web access to the paper: http://www.comp.rgu.ac.uk/staff/chb/research/papers/bryant_ilp05.pdf
Paper format: late breaking papers (6 pages)

Bibtex entry for the paper:

	@incollection{bryant:ilp05,
	AUTHOR = "C.H. Bryant and D. Fredouille",
	TITLE = "A Parser for the Efficient Induction of Biological Grammars",
        URL = "http://www.comp.rgu.ac.uk/staff/chb/research/papers/bryant_ilp05.pdf",
	BOOKTITLE = "Fifteenth International Conference on Inductive
	Logic Programming: late-breaking paper track.", 
	PUBLISHER = "University of Bonn",
	YEAR = 2005,
	EDITOR = "S. Kramer and B. Pfahringer",
	ADDRESS = "Bonn, Germany",
        MONTH = "July",
	NOTE = "http://wwwbib.informatik.tu-muenchen.de/infberichte/2005/TUM-I0510.idx"}

For any questions, bug report or remarks on the content of this page, please contact the authors. We always enyoy feedback and questions.

Software

To run experiments of the paper, or to use our software for your own experiments using parsing, you will first need to install Yap, and if you want to reproduce/realise experiments related to inference you have also to install Aleph.

The software presented in the paper provides new predicates in Yap. These predicates are related to context-free grammar parsing with the DFTD algorithm. To use these predicates, you will need to download and compile (gcc compilation) the following package: dftdp_in_yap.tar.gz.

You will find in this package:

A README file.
The code of the parser and of the link between the parser and the Yap system.
An example of how to use the parser from Yap.
Examples of how to use the parser in inference with Aleph.
An html documentation on the code (automatically generated using Doxygen). As a user, you will certainly be interested only in the Methods to call from Yap as built-in predicates section of this documentation. Other sections of this documentation are useful to people desiring to modify the code of the package.
Warning: The software is not "user proof". This means that if the execution of the predicates related to parsing are not made in the right order (e.g. if you forget to initialise the parser before calling it for parsing a sequence, or that you try to access sequences that have not been stored), the software will crash. If this happens to you, you can sometimes obtain informations on why the software crashed by turning off (i.e., removing) the -DNDEBUG compilation option and running your program again. After identifying and correcting the problem, you can turn on -DNDEBUG again, since this will enable a more efficient parsing in term of running times.

Data sets

Experiments of Section 2: "Introducing the parser in a Prolog engine"

These experiments consisted in parsing grammars obtained during an ILP process with both Yap Prolog engine and our parsers called from Yap.

Available files to reproduce the experiments:

The inference files enabling to obtain the set of grammar we parsed: set_construction.tar.gz. It contains:

A README file.
The examples and counter-examples used for inference.
The background knowledge file used to save grammar rules obtained during inference
Different useful scripts to run the inference process and format its output.
Warning: The set of grammar rules obtained with the files of this package is not online due to web space requirements (files of size 84840Mb and 28632Mb), you can obtain them by running the package, or by contacting the authors (ask for files: res_clauses.pl and res_rules.txt, directory ebga/experiments/parser_speed/3-test_with_yap_and_grammar_parser/1-middle/parsing_times_Yap_CProgol_and_us/data/grammar_rules/clauselength=10_nodes=150000/

The files used to parse the sequences named "middles" in the grammars obtained on the previous point: set_parsing.tar.gz. This package contains:

A README file,
The sequences to parse,
Scripts to split the set of sequences and grammars to parse in function of their size,
Prolog files containing the code to parse the sequences in the grammars,
Python scripts to run the parsing on the different examples and grammar files.

Experiments of Section 3: "Introducing the parser in ILP"

These experiments consisted in inferring grammars from sets of sequences and background knowledge, and measuring inference times when the sequences are analysed using Yap, or when using our parser.

Here is the package to reproduce these experiments [*]: infer_on_middles.tar.gz
The package contains:

A README file
The positive and randoms examples used for inference
For each algorithm used in the paper (i-yap, i-yap-cost, i-dftd, i-dftd-cost) :

Its associated background knowledge file
A Prolog file to realise inference
A script to run inference (downloading the Prolog file in Yap and filtering the output)

Footnotes

[*] To use this package, you should have installed the software to call the DFTD parser from Yap (see Section "software").