Overall goal

Make it easy to share packed representations across NLP applications.
Therefore we want a spec that is primarily easy to use from a variety of different platforms and languages.
A memory efficient and fast representation is also useful.

Serialization library options

JSON

Need additional code to check for well-formed hypergraphs, since there is no schema for JSON objects

Some languages (e.g., Python) do not natively support event-driven parsers for JSON, meaning it's hard to do process JSON files without first loading the entire thing. Since parse forests can be big in real applications, event-driven parsers that construct a hypergraph library's internal data structure are crucial.

Proposed schema:

A Forest object has the following required fields:

nodes: a list of Node objects

edges: a list of Edge objects

root: a node id, which is an integer index into the nodes list

An Edge object has the following required fields:

head: a node id

tails: a (possibly empty) list of node ids

A Node or Edge object has the following optional fields:

label: string

features: a FeatureVector object

and any other application-specific fields.

(ChrisD) question: some libraries don't represent node-level features internally (at least Joshua & cdec), so these would need to denormalize node-level features to either all incoming or outgoing edges of the node in question. This may not be completely straightforward to do. Should we possibly consider just edge-level features?

Proposed extensions (yea or nay?) / Open questions

When a hypergraph represents a set of trees, the Node.labels will be the labels of the tree nodes. It might be convenient to allow a shorthand for leaf/terminal labels: in Edge.tails, a string "a" would be shorthand for {label: "a"}

In Node.label, a value of null means that the tree node is labeled with epsilon, the empty string. This is not the same as ""': the former would not contribute anything to the yield of the tree, whereas the latter would contribute a token of length 0.

David Chiang: nay, this should be left to the application. An empty Edge.tails list has the same effect. And people who care about explicit empty nodes might want to distinguish several kinds of empty nodes (t, PRO, pro, etc.).

ChrisD: nay. agree with David.

When a hypergraph represents a CFG, the Nodes will be the nonterminal symbols and the Edges will be the productions. It will be ugly for numeric Node ids to appear in the productions, so symbolic names might be preferable. Perhaps a Node object can have a string-valued id field by which it can be referred to. Con: who is going to guarantee that the names are unique? Alternatively, a Forest object can have a nodealiases field which is an object mapping from symbolic names to numeric ids.

ChrisD: I'm in favor of referring to nodes/nonterminals with a numeric id for consistency enforcement (which is admittedly ugly), but supporting optional string aliases/labels for applications that care about such things.

Another possible extension for edges: it may be useful to encode synchronous forests (for example, imagine the forest of derivations over an input lattice). Do we want to have an optional alt_tails? or a vector of tails (for multiple languages?)?

What do we think about non-coaccessible states? Is a forest well-formed if it contains elements that cannot be reached from the root?

Protocol Buffers

Very fast to read (particularly in C++ and Java, hopefully soon in python)

Very space efficient

Implementations in Java, C++ and Python; generates typed stubs in those languages

Con:

No implementations for Perl, C#, or other languages commonly used by NLP folks

Requires a separate library; adds an external dependency to spec

"It's really easy to get up to some of the data size limits that are in place to prevent malicious data from having the PB parser allocate too much memory". Some of the limits are described in the section describing SetTotalBytesLimit on this page.

"You typically have to create a full hypergraph protocol buffer object before you can serialize it, so you either have to use the PB data structures internally in your code or you have to copy your data structure. While doing this copy, you can end up with two copies of the forest in memory, which is bad for memory usage."