Main Page
From Dyna
Contents |
Dyna
Dyna is a small, very-high-level programming language that makes it easy to specify dynamic programs and train their weights. You write a short declarative specification in Dyna, and the Dyna optimizing compiler produces efficient C++ classes that form the core of your C++ application.
Natural applications in NLP include various kinds of parsing, machine translation, speech decoding, and finite-state modeling. Dyna also has many other applications, especially in other applied AI areas, since dynamic programming (and its degenerate case, tree search) is a common strategy for solving combinatorial optimization problems.
Properly speaking, Dyna is a "weighted" logic programming language: terms have values, and Horn clauses are replaced by aggregation equations. It is Turing-complete. You can also think of Dyna as extending compiled C++ with powerful deductive database features.
Looking for something? Try the FAQ, the documentation page (which serves as a site map), or the search box to your left.
Download
You can download Dyna v0.3.10 as RPM or tarball. (This alpha release is useful, but note that we are currently redesigning and reimplementing from the ground up.) Dyna runs on Unix/Linux platforms and on Windows with Cygwin. See the detailed list of supported platforms on the download page. Please let us know of any problems. See also: version history.
Documentation
We have published some papers, accompanied by detailed talk slides.
Much of this wiki is badly out of date because Dyna is currently in very active development; both the language definition and the implementation are changing.
- overview of Dyna (still useful, though out of date)
- tutorial for downloadable prototype (partial)
- installation guide for downloadable prototype (up to date)
- reference guide (badly out of date)
- bibliography of further reading (up to date)
Project status
We are currently in the middle of redesigning and reimplementing everything from the ground up. The currently released prototype (v0.3.10) was useful for our own work, and we learned a lot from building and using it. But after a few years' hiatus, we are working again on the much more ambitious version 2, which will be the one to watch out for. See our recent papers for some hints about what's coming.
- Functionality: The prototype supports many NLP applications. This subset permits tabled forward-chaining computation on ground terms, using semiring weights; training is supported for real-valued weights. The forthcoming version 2 will be considerably more expressive and flexible, generalizing the prototype on all the above points and more.
- Usefulness: We have presented a variety of statistical NLP papers (at ACL, EMNLP, AMTA, CoNLL, IWPT, ...) that did all their implementation using the Dyna prototype. We also used it to teach. We believe that Version 2 will be able to handle the vast majority of the ML and NLP research that we want to do or see others doing.
- Efficiency: The compiled code in the prototype is carefully designed C++ code and is adequately fast for research. The forthcoming version 2 is starting as an interpreter, but it is ultimately intended to be competitive with hand-tuned systems (e.g., we expect a 5x speedup on parsing). It allows optional declarations that provide considerably more control over implementation details, including search and caching strategies and the details of how data are stored, accessed, and indexed. (Our eventual plan is for an optimizer to select these strategies automatically, to maximize empirical performance on a given dataset and machine.) For further efficiency and convenience, version 2 also supports cleaner integration with user-defined C++ classes and methods.
- Usability: The language is concise and readable, with full support for Unicode and user-defined syntactic sugar. For modularity, each "dynabase" is a live deductive database that may be represented as Dyna source code, as a compact binary file, as a web resource, or as another file format (e.g., spreadsheet) for which a front-end has been written. It is easy to hook together dynabases that contain heterogeneous data, grammars, algorithms, etc. We have been developing a graphical browser to inspect dynabases. There is also support for linking in functions in other languages.
- Theoretical grounding: We have a formal semantics, an interesting type system (for version 2), a set of powerful source-to-source program transformations, etc. See Blatz & Eisner (2007) for partial details.
About the Dyna project
Dyna is an open-source project led by Prof. Jason Eisner, at Johns Hopkins University's Computer Science Department, Center for Language and Speech Processing, and Human Language Technology Center of Excellence.
- Present and past contributors to the all-new version we're working on:
- Prof. Jason Eisner (project leader)
- Nathaniel "Wes" Filardo, Wren Ng Thornton (core compiler)
- Jay Van Der Wall (concrete syntax)
- John Blatz (program transformations, inference algorithms)
- Johnny Graettinger, Eric Northup (early phase of redesign)
- Past contributors to the currently available prototype:
- Prof. Jason Eisner (project leader)
- Eric Goldlust (core compiler)
- Noah A. Smith (DynaMITE parameter training module)
- Markus Dreyer (source language processing, testing, program transformations)
- David A. Smith (builds & distributions)
- Roy Tromble (FST applications and Dyna development tools)
- Asheesh Laroia (the dyna.org website)
- Contributors to the Dynasty graph browser, which will become a visual debugger for Dyna:
- Prof. Jason Eisner (project leader)
- Michael Kornbluh (initial version)
- Gordon Woodhull (graph layout)
- Ian Nowland (latest version)
- Samuel Huang
- George Shafer
- Raymond Buse
- Constantinos Michael
See the Developers page if you are interested in internals and/or would like to participate!
We are grateful for funding from the following generous sponsors, who do not necessarily endorse or subscribe to the opinions, findings, conclusions, or recommendations expressed on this website:
- NSF ITR grant IIS-0313193, "Weighted Dynamic Programming for Statistical Natural Language Processing"
- ONR MURI grant N00014-01-1-0685, "Improving Statistical Translation Models via Text Analyzers Trained from Parallel Corpora"
- NSF grant 0347822, "CAREER: Finite State Machine Learning on Strings and Sequences"
- The Human Language Technology Center of Excellence at Johns Hopkins University.
- An HLTCOE Fellowship to Wes; Wolman Fellowships to Eric and Markus; a Hertz Foundation Fellowship to Noah; a Pistritto Fellowship to Mike; an NSF Fellowship to David; and an NSDEG Fellowship to Roy. (What an amazing group of students!)
We are also grateful to these local establishments.
How to acknowledge Dyna in your own work
How you can help
- Please send us your confused questions, bug reports, feature requests, and interesting examples.
- We are looking for a creative postdoc with strong background in machine learning, declarative languages, or parsing algorithms.
- Feel free to improve this website yourself. You can edit without permission; it uses the same software as Wikipedia.
