parsedtoplot

Plots constituency trees and dependency trees given by strings.

Overview

The code uses both the id-tree crate and the plotters crate. Primarily written for inputs like parsed syntactic trees, but can serve other inputs, such as mathematical expressions etc. The program first transforms the input to a conll / tree, then plots the structure, recursively. It is mostly suitable for short parsed sequences of up to 15-20 tokens. The program is a simple drawing program, plots strings that are already parsed. This is not a parser! I wrote this in order to get familiar with Rust and decided to upload it if it can help others.

Input-Output

• The API expects a string input. Multiple string inputs can be delivered in a file, through the command-line.
• For constituency trees, the program takes a parsed string given in one line. The string can be syntactic, for example such that represents phrases and parts-of-speech (as the structure in Berkeley Neural Parser in python). Such strings will have "double leaves" (see an example below). Alternatively, the strings can have singular leaves, representing, for example, mathematical expressions.
• For dependency trees, the programs takes a conll format, in which every token has 10 fields, separated by tab, and presented in a new line. Sentences are separated by an empty line. (see an example below, using an output from spaCy in python).
• For multiple inputs of the same type, the program expects 3 arguments from the command-line:
  • input type ("c" = constituency / "d" = dependency), String
  • input file path, String
  • output path, String

See an example below.

Usage examples

Constituency

The following example shows how to use the API in order to produce a png from a single parsed constituency string.

``` // Example parsed sentence: // (S (NP (det The) (N people)) (VP (V watch) (NP (det the) (N game))))

use parsedtoplot::Config; use parsedtoplot::String2Tree; use parsedtoplot::Tree2Plot; use parsedtoplot::String2StructureBuilder; use parsedtoplot::Structure2PlotBuilder;

let mut constituency = String::from("(S (NP (det The) (N people)) (VP (V watch) (NP (det the) (N game))))"); let mut string2tree: String2Tree = String2StructureBuilder::new(); string2tree.build(&mut constituency).unwrap(); // build the tree from the string let tree = string2tree.get_structure();

// build plot from tree and save Config::makeoutdir(&"Output".tostring()).unwrap(); let saveto: &str = "Output/constituencyplot.png"; let mut tree2plot: Tree2Plot = Structure2PlotBuilder::new(tree); tree2plot.build(saveto); ```

Dependency

The following example shows how to use the API in order to produce a png from a single conll format.

``` // 0 The the det _ _ 1 det _ _ // 1 people people NOUN _ _ 2 nsubj _ _ // 2 watch watch VERB _ _ 2 ROOT _ _ // 3 the the DET _ _ 4 det _ _ // 4 game game NOUN _ _ 2 dobj _ _

use parsedtoplot::Config; use parsedtoplot::String2Conll; use parsedtoplot::Conll2Plot; use parsedtoplot::String2StructureBuilder; use parsedtoplot::Structure2PlotBuilder;

let mut dependency = [ "0 The the DET _ _ 1 det _ ", "1 people people NOUN _ _ 2 nsubj _ _", "2 watch watch VERB _ _ 2 ROOT _ _", "3 the the DET _ _ 4 det _ _", "4 game game NOUN _ _ 2 dobj _ _" ].map(|x| x.tostring()).to_vec();

let mut string2conll: String2Conll = String2StructureBuilder::new(); string2conll.build(&mut dependency).unwrap(); // build the conll from the vector of strings let conll = string2conll.get_structure();

// build plot from conll and save Config::makeoutdir(&"Output".tostring()).unwrap(); let saveto: &str = "Output/dependencyplot.png"; let mut conll2plot: Conll2Plot = Structure2PlotBuilder::new(conll); conll2plot.build(saveto); ```

Multiple inputs via file

You can use multiple inputs of the same type in a file, through the command-line, as follows:

cargo run INPUT_TYPE INPUT_FILE OUTPUT_PATH

when: * INPUTTYPE should be replaced with "c" for constituency or "d" for dependency. * INPUTFILE should be replaced with a path to a txt file with inputs. * OUTPUT_PATH should be replaced with a path to a requested output dir.

For example:

cargo run c constituencies.txt Output

Will save png images of constituency trees drawn for the inputs in constituencies.txt, in an Output dir.

Constituency

``` use parsedtoplot::Config; use parsedtoplot::String2Tree; use parsedtoplot::Tree2Plot; use parsedtoplot::String2StructureBuilder; use parsedtoplot::Structure2PlotBuilder; use std::env;

// collect arguments from command line let args: Vec = env::args().collect(); // note: your command line args should translate to something similar to the following: // let args: Vec = ["PROGRAMNAME", "c", "Input/constituencies.txt", "ConOutput"].map(|x| x.tostring()).to_vec();

// run configuration protocol and inspectations let sequences = match Config::new(&args) { Ok(sequences) => Vec::::try_from(sequences).unwrap(), Err(config) => panic!("{}", config) };

for (i, mut constituency) in sequences.into_iter().enumerate() {

println!("working on input number {} ...", i);
let save_to = &Config::get_out_file(&args[3], i.to_string().as_str());

// build tree from consituency
let mut string2tree: String2Tree = String2StructureBuilder::new();
string2tree.build(&mut constituency).unwrap();
let tree = string2tree.get_structure();

// build plot from tree
let mut tree2plot: Tree2Plot = Structure2PlotBuilder::new(tree);
tree2plot.build(save_to);

} ```

Dependency

``` use parsedtoplot::Config; use parsedtoplot::String2Conll; use parsedtoplot::Conll2Plot; use parsedtoplot::String2StructureBuilder; use parsedtoplot::Structure2PlotBuilder; use std::env;

// collect arguments from command line let args: Vec = env::args().collect(); // note: your command line args should translate to something similar to the following: // let args: Vec = ["PROGRAMNAME", "d", "Input/conll.txt", "DepOutput"].map(|x| x.tostring()).to_vec();

// run configuration protocol and inspectations let sequences = match Config::new(&args) { Ok(sequences) => Vec::>::try_from(sequences).unwrap(), Err(config) => panic!("{}", config) };

for (i, mut dependency) in sequences.into_iter().enumerate() {

println!("working on input number {} ...", i);
let save_to = &Config::get_out_file(&args[3], i.to_string().as_str());

// build conll from string
let mut string2conll: String2Conll = String2StructureBuilder::new();
string2conll.build(&mut dependency).unwrap();
let conll = string2conll.get_structure();

// build plot from conll
let mut conll2plot: Conll2Plot = Structure2PlotBuilder::new(conll);
conll2plot.build(save_to);

} ```

References

• I used the crates: id-tree, plotters.
• I used spaCy to create a couple of dependency-parsed examples for illustration.

License

Under MIT license.