⚠️ Warning

Usage

Command line

# grammar.cfgS   -> NP VP   (0.8)    # specify probability between 0 and 1 by appending between parenthesesS   -> NP      (0.2)NP  -> Det N            # probability defaults to 1.0NP  -> Det Nom          # all rules for a given category must sum to 1, so the builder normalizes probabilities to ensure they sum to 1.0Nom -> Adj NVP  →  V                # Use '->' or '→'Det →  the              # probability defaults to 1.0N   →  heavy   (0.2)Adj →  heavy   (0.8)V   →  heave   (0.8)N   →  /heave[r]?/i   (0.2) # You can specify terminals as regular expressions by enclosing them in '/'.

java -jar probabilistic-earley-parser-jar-with-dependencies.jar -i grammar.cfg -goal S the heavy heave

0.128 (= 0.8 * 0.2 * 0.8)└── <start>    └── S        ├── NP        │   ├── Det        │   │   └── the (the)        │   └── N        │       └── heavy (heavy)        └── VP            └── V                └── heave (heave)

0.032 (= 0.2 * 0.8 * 0.2)└── <start>    └── S        └── NP            ├── Det            │   └── the (the)            └── Nom                ├── Adj                │   └── heavy (heavy)                └── N                    └── heave (heave)

Java API

<dependencies>        <dependency>            <groupId>org.leibnizcenter</groupId>            <artifactId>probabilistic-earley-parser</artifactId>            <version>0.9.12</version>        </dependency></dependencies>

compile'org.leibnizcenter:probabilistic-earley-parser:0.9.12'

publicclassExample {// NonTerminals are just wrappers around a stringprivatestaticfinalNonTerminalS =Category.nonTerminal("S");privatestaticfinalNonTerminalNP =Category.nonTerminal("NP");privatestaticfinalNonTerminalVP =Category.nonTerminal("VP");privatestaticfinalNonTerminalTV =Category.nonTerminal("TV");privatestaticfinalNonTerminalDet =Category.nonTerminal("Det");privatestaticfinalNonTerminalN =Category.nonTerminal("N");privatestaticfinalNonTerminalMod =Category.nonTerminal("Mod");// Terminal types are realized by implementing the Terminal interface, specifically the function hasCategory. Terminal is a functional interface.// Note that tokens can be of multiple terminal types (homographs: "bank" as a noun or "bank" as a verb), so you can use this method to pool many words to a single terminalprivatestaticfinalTerminal<String>transitiveVerb =token ->token.obj.matches("(hit|chased)");// Some utility terminal types are pre-defined:privatestaticfinalTerminal<String>the =newCaseInsensitiveStringTerminal("the");privatestaticfinalTerminal<String>a =newCaseInsensitiveStringTerminal("a");privatestaticfinalTerminal<String>man =newExactStringTerminal("man");privatestaticfinalTerminal<String>stick =newExactStringTerminal("stick");privatestaticfinalTerminal<String>with =newExactStringTerminal("with");privatestaticfinalGrammargrammar =newGrammar.Builder("test")            .setSemiring(LogSemiring.get())// If not set, defaults to Log semiring which is probably what you want. The builder takes care of converting probabilties to semiring elements            .addRule(1.0,// Probability between 0.0 and 1.0, defaults to 1.0S,// Left hand side of the ruleNP,VP// Right hand side of the rule            )            .addRule(NP,Det,N// eg. The man            )            .addRule(NP,Det,N,Mod// eg. The man (with a stick)            )            .addRule(0.4,VP,TV,NP,Mod// eg. (chased) (the man) (with a stick)            )            .addRule(0.6,VP,TV,NP// eg. (chased) (the man with a stick)            )            .addRule(Det,a)            .addRule(Det,the)            .addRule(N,man)            .addRule(N,stick)            .addRule(TV,transitiveVerb)            .addRule(Mod,with,NP)// eg. with a stick            .build();publicstaticvoidmain(String[]args) {Parser<String>parser =newParser<>(grammar);System.out.println(parser.recognize(S,Tokens.tokenize("The man     chased the man\n\t with a stick"))// true        );System.out.println(parser.getViterbiParseWithScore(S,Tokens.tokenize("the","stick","chased","the","man"))// Most likely parse tree with probability        );    }}

Grammar<String> g = Grammar.fromString(Paths.get("path", "to", "grammar.cfg"), Charset.forName("UTF-8"));

new ParseCallbacks.Builder()                        .withOnPreScan((position, token, chart) -> System.out.println("Scan about to happen for token " + token))                        .withScanProbability((position, token) -> {                            if (token.getCategories().contains(anUnexpectedTerminalForThisWord)) {                                return grammar.semiring.fromProbability(0.5);                            } else {                                return grammar.semiring.one();                            }                        })                        .withOnPostScan((position, token, chart) -> System.out.println("Scan happened for token " + token))                        .withOnPostComplete((position, token, chart) -> System.out.println("Complete happened for token " + token))                        .build()

Some notes on implementation

Runtime complexity

Limitations

Semirings

License

References

Contact