public ParserAnnotator(string annotatorName, Properties props)
{
string model = props.GetProperty(annotatorName + ".model", LexicalizedParser.DefaultParserLoc);
if (model == null)
{
throw new ArgumentException("No model specified for Parser annotator " + annotatorName);
}
this.Verbose = PropertiesUtils.GetBool(props, annotatorName + ".debug", false);
string[] flags = ConvertFlagsToArray(props.GetProperty(annotatorName + ".flags"));
this.parser = LoadModel(model, Verbose, flags);
this.maxSentenceLength = PropertiesUtils.GetInt(props, annotatorName + ".maxlen", -1);
string treeMapClass = props.GetProperty(annotatorName + ".treemap");
if (treeMapClass == null)
{
this.treeMap = null;
}
else
{
this.treeMap = ReflectionLoading.LoadByReflection(treeMapClass, props);
}
this.maxParseTime = PropertiesUtils.GetLong(props, annotatorName + ".maxtime", -1);
this.kBest = PropertiesUtils.GetInt(props, annotatorName + ".kbest", 1);
this.keepPunct = PropertiesUtils.GetBool(props, annotatorName + ".keepPunct", true);
string buildGraphsProperty = annotatorName + ".buildgraphs";
if (!this.parser.GetTLPParams().SupportsBasicDependencies())
{
if (PropertiesUtils.GetBool(props, buildGraphsProperty))
{
log.Info("WARNING: " + buildGraphsProperty + " set to true, but " + this.parser.GetTLPParams().GetType() + " does not support dependencies");
}
this.BuildGraphs = false;
}
else
{
this.BuildGraphs = PropertiesUtils.GetBool(props, buildGraphsProperty, true);
}
if (this.BuildGraphs)
{
bool generateOriginalDependencies = PropertiesUtils.GetBool(props, annotatorName + ".originalDependencies", false);
parser.GetTLPParams().SetGenerateOriginalDependencies(generateOriginalDependencies);
ITreebankLanguagePack tlp = parser.GetTLPParams().TreebankLanguagePack();
IPredicate <string> punctFilter = this.keepPunct ? Filters.AcceptFilter() : tlp.PunctuationWordRejectFilter();
this.gsf = tlp.GrammaticalStructureFactory(punctFilter, parser.GetTLPParams().TypedDependencyHeadFinder());
}
else
{
this.gsf = null;
}
this.nThreads = PropertiesUtils.GetInt(props, annotatorName + ".nthreads", PropertiesUtils.GetInt(props, "nthreads", 1));
bool usesBinary = StanfordCoreNLP.UsesBinaryTrees(props);
this.saveBinaryTrees = PropertiesUtils.GetBool(props, annotatorName + ".binaryTrees", usesBinary);
this.noSquash = PropertiesUtils.GetBool(props, annotatorName + ".nosquash", false);
this.extraDependencies = MetaClass.Cast(props.GetProperty(annotatorName + ".extradependencies", "NONE"), typeof(GrammaticalStructure.Extras));
}
public DependencyParseAnnotator(Properties properties)
{
string modelPath = PropertiesUtils.GetString(properties, "model", DependencyParser.DefaultModel);
parser = DependencyParser.LoadFromModelFile(modelPath, properties);
nThreads = PropertiesUtils.GetInt(properties, "testThreads", DefaultNthreads);
maxTime = PropertiesUtils.GetLong(properties, "sentenceTimeout", DefaultMaxtime);
extraDependencies = MetaClass.Cast(properties.GetProperty("extradependencies", "NONE"), typeof(GrammaticalStructure.Extras));
}
private static SemanticGraph GetParse(ICoreMap sentence)
{
GrammaticalStructure gs = parser.Predict(sentence);
GrammaticalStructure.Extras maximal = GrammaticalStructure.Extras.Maximal;
// SemanticGraph deps = SemanticGraphFactory.makeFromTree(gs, SemanticGraphFactory.Mode.ENHANCED, maximal, true, null),
// uncollapsedDeps = SemanticGraphFactory.makeFromTree(gs, SemanticGraphFactory.Mode.BASIC, maximal, true, null),
// SemanticGraph ccDeps = SemanticGraphFactory.makeFromTree(gs, SemanticGraphFactory.Mode.ENHANCED_PLUS_PLUS, maximal, true, null);
SemanticGraph ccDeps = SemanticGraphFactory.GenerateEnhancedPlusPlusDependencies(gs);
return(ccDeps);
}
public ParserAnnotator(ParserGrammar parser, bool verbose, int maxSent, Func <Tree, Tree> treeMap)
{
this.Verbose = verbose;
this.BuildGraphs = parser.GetTLPParams().SupportsBasicDependencies();
this.parser = parser;
this.maxSentenceLength = maxSent;
this.treeMap = treeMap;
this.maxParseTime = 0;
this.kBest = 1;
this.keepPunct = true;
if (this.BuildGraphs)
{
ITreebankLanguagePack tlp = parser.GetTLPParams().TreebankLanguagePack();
this.gsf = tlp.GrammaticalStructureFactory(tlp.PunctuationWordRejectFilter(), parser.GetTLPParams().TypedDependencyHeadFinder());
}
else
{
this.gsf = null;
}
this.nThreads = 1;
this.saveBinaryTrees = false;
this.noSquash = false;
this.extraDependencies = GrammaticalStructure.Extras.None;
}
//private static HeadFinder shf = new ChineseHeadFinder();
protected internal override void CollapseDependencies(IList <TypedDependency> list, bool CCprocess, GrammaticalStructure.Extras includeExtras)
{
// collapseConj(list);
CollapsePrepAndPoss(list);
}
public static SemanticGraph MakeFromTree(Tree tree, SemanticGraphFactory.Mode mode, GrammaticalStructure.Extras includeExtras)
{
return(MakeFromTree(tree, mode, includeExtras, null, false));
}
public static SemanticGraph MakeFromTree(Tree tree, SemanticGraphFactory.Mode mode, GrammaticalStructure.Extras includeExtras, IPredicate <TypedDependency> filter)
{
return(MakeFromTree(tree, mode, includeExtras, filter, false));
}
// TODO: these booleans would be more readable as enums similar to Mode.
// Then the arguments would make more sense
public static SemanticGraph MakeFromTree(GrammaticalStructure gs, SemanticGraphFactory.Mode mode, GrammaticalStructure.Extras includeExtras, IPredicate <TypedDependency> filter)
{
ICollection <TypedDependency> deps;
switch (mode)
{
case SemanticGraphFactory.Mode.Enhanced:
{
deps = gs.TypedDependenciesEnhanced();
break;
}
case SemanticGraphFactory.Mode.EnhancedPlusPlus:
{
deps = gs.TypedDependenciesEnhancedPlusPlus();
break;
}
case SemanticGraphFactory.Mode.CollapsedTree:
{
deps = gs.TypedDependenciesCollapsedTree();
break;
}
case SemanticGraphFactory.Mode.Collapsed:
{
deps = gs.TypedDependenciesCollapsed(includeExtras);
break;
}
case SemanticGraphFactory.Mode.Ccprocessed:
{
deps = gs.TypedDependenciesCCprocessed(includeExtras);
break;
}
case SemanticGraphFactory.Mode.Basic:
{
deps = gs.TypedDependencies(includeExtras);
break;
}
default:
{
throw new ArgumentException("Unknown mode " + mode);
}
}
if (filter != null)
{
IList <TypedDependency> depsFiltered = Generics.NewArrayList();
foreach (TypedDependency td in deps)
{
if (filter.Test(td))
{
depsFiltered.Add(td);
}
}
deps = depsFiltered;
}
// there used to be an if clause that filtered out the case of empty
// dependencies. However, I could not understand (or replicate) the error
// it alluded to, and it led to empty dependency graphs for very short fragments,
// which meant they were ignored by the RTE system. Changed. (pado)
// See also the SemanticGraph constructor.
//log.info(deps.toString());
return(new SemanticGraph(deps));
}
/// <summary>
/// Returns a new
/// <c>SemanticGraph</c>
/// constructed from a given
/// <see cref="Edu.Stanford.Nlp.Trees.Tree"/>
/// with given options.
/// This factory method is intended to replace a profusion of highly similar
/// factory methods, such as
/// <c>typedDependencies()</c>
/// ,
/// <c>typedDependenciesCollapsed()</c>
/// ,
/// <c>allTypedDependencies()</c>
/// ,
/// <c>allTypedDependenciesCollapsed()</c>
/// , etc.
/// For a fuller explanation of the meaning of the boolean arguments, see
/// <see cref="Edu.Stanford.Nlp.Trees.GrammaticalStructure"/>
/// .
/// </summary>
/// <param name="tree">A tree representing a phrase structure parse</param>
/// <param name="includeExtras">
/// Whether to include extra dependencies, which may
/// result in a non-tree
/// </param>
/// <param name="filter">A filter to exclude certain dependencies; ignored if null</param>
/// <param name="originalDependencies">
/// generate original Stanford dependencies instead of new
/// Universal Dependencies
/// </param>
/// <returns>A SemanticGraph</returns>
public static SemanticGraph MakeFromTree(Tree tree, SemanticGraphFactory.Mode mode, GrammaticalStructure.Extras includeExtras, IPredicate <TypedDependency> filter, bool originalDependencies, bool includePunctuationDependencies)
{
GrammaticalStructure gs;
if (originalDependencies)
{
IPredicate <string> wordFilt;
if (includePunctuationDependencies)
{
wordFilt = Filters.AcceptFilter();
}
else
{
wordFilt = new PennTreebankLanguagePack().PunctuationWordRejectFilter();
}
gs = new EnglishGrammaticalStructure(tree, wordFilt, new SemanticHeadFinder(true));
}
else
{
IPredicate <string> tagFilt;
if (includePunctuationDependencies)
{
tagFilt = Filters.AcceptFilter();
}
else
{
tagFilt = new PennTreebankLanguagePack().PunctuationTagRejectFilter();
}
gs = new UniversalEnglishGrammaticalStructure(tree, tagFilt, new UniversalSemanticHeadFinder(true));
}
return(MakeFromTree(gs, mode, includeExtras, filter));
}
public static SemanticGraph MakeFromTree(Tree tree, SemanticGraphFactory.Mode mode, GrammaticalStructure.Extras includeExtras, IPredicate <TypedDependency> filter, bool originalDependencies)
{
return(MakeFromTree(tree, mode, includeExtras, filter, originalDependencies, IncludePunctuationDependencies));
}
public static SemanticGraph GenerateCCProcessedDependencies(GrammaticalStructure gs, GrammaticalStructure.Extras extras)
{
return(MakeFromTree(gs, SemanticGraphFactory.Mode.Ccprocessed, extras, null));
}
public static SemanticGraph GenerateUncollapsedDependencies(GrammaticalStructure gs, GrammaticalStructure.Extras extras)
{
return(MakeFromTree(gs, SemanticGraphFactory.Mode.Basic, extras, null));
}
// static methods
/// <summary>
/// Put the tree in the CoreMap for the sentence, also add any
/// dependency graphs to the sentence, and fill in missing tag annotations.
/// </summary>
/// <remarks>
/// Put the tree in the CoreMap for the sentence, also add any
/// dependency graphs to the sentence, and fill in missing tag annotations.
/// Thread safety note: nothing special is done to ensure the thread
/// safety of the GrammaticalStructureFactory. However, both the
/// EnglishGrammaticalStructureFactory and the
/// ChineseGrammaticalStructureFactory are thread safe.
/// </remarks>
public static void FillInParseAnnotations(bool verbose, bool buildGraphs, IGrammaticalStructureFactory gsf, ICoreMap sentence, IList <Tree> trees, GrammaticalStructure.Extras extras)
{
bool first = true;
foreach (Tree tree in trees)
{
// make sure all tree nodes are CoreLabels
// TODO: why isn't this always true? something fishy is going on
Edu.Stanford.Nlp.Trees.Trees.ConvertToCoreLabels(tree);
// index nodes, i.e., add start and end token positions to all nodes
// this is needed by other annotators down stream, e.g., the NFLAnnotator
tree.IndexSpans(0);
if (first)
{
sentence.Set(typeof(TreeCoreAnnotations.TreeAnnotation), tree);
if (verbose)
{
log.Info("Tree is:");
tree.PennPrint(System.Console.Error);
}
SetMissingTags(sentence, tree);
if (buildGraphs)
{
// generate the dependency graph
// unfortunately, it is necessary to make the
// GrammaticalStructure three times, as the dependency
// conversion changes the given data structure
SemanticGraph deps = SemanticGraphFactory.GenerateCollapsedDependencies(gsf.NewGrammaticalStructure(tree), extras);
SemanticGraph uncollapsedDeps = SemanticGraphFactory.GenerateUncollapsedDependencies(gsf.NewGrammaticalStructure(tree), extras);
SemanticGraph ccDeps = SemanticGraphFactory.GenerateCCProcessedDependencies(gsf.NewGrammaticalStructure(tree), extras);
SemanticGraph enhancedDeps = SemanticGraphFactory.GenerateEnhancedDependencies(gsf.NewGrammaticalStructure(tree));
SemanticGraph enhancedPlusPlusDeps = SemanticGraphFactory.GenerateEnhancedPlusPlusDependencies(gsf.NewGrammaticalStructure(tree));
if (verbose)
{
log.Info("SDs:");
log.Info(deps.ToString(SemanticGraph.OutputFormat.List));
}
sentence.Set(typeof(SemanticGraphCoreAnnotations.CollapsedDependenciesAnnotation), deps);
sentence.Set(typeof(SemanticGraphCoreAnnotations.BasicDependenciesAnnotation), uncollapsedDeps);
sentence.Set(typeof(SemanticGraphCoreAnnotations.CollapsedCCProcessedDependenciesAnnotation), ccDeps);
sentence.Set(typeof(SemanticGraphCoreAnnotations.EnhancedDependenciesAnnotation), enhancedDeps);
sentence.Set(typeof(SemanticGraphCoreAnnotations.EnhancedPlusPlusDependenciesAnnotation), enhancedPlusPlusDeps);
}
first = false;
}
}
if (trees.Count > 1)
{
sentence.Set(typeof(TreeCoreAnnotations.KBestTreesAnnotation), trees);
}
}
