public virtual void TestCompose()
{
IFunction <int, int> plusOne = null;
IFunction <int, int> doubler = null;
IFunction <int, int> composed = Functions.Compose(plusOne, doubler);
NUnit.Framework.Assert.AreEqual(composed.Apply(1), 3);
NUnit.Framework.Assert.AreEqual(composed.Apply(2), 5);
}
public void TestFunction(IFunction function, JToken args, JToken expected)
{
var actual = args != null?function.Apply(args) : function.Apply();
(actual == null).Should().Be(expected == null, "actual and expected should both be present or not");
if (actual != null)
{
actual.Should().BeEquivalentTo(expected);
}
}
public object Apply(IContext context, IList <object> arguments, IDictionary <string, object> namedArguments)
{
var dynobj = new DynamicObject(this);
if (this.HasMethod(ConstructorName))
{
IFunction constructor = this.GetMethod(ConstructorName);
IList <object> args = new List <object>()
{
dynobj
};
if (arguments != null && arguments.Count > 0)
{
foreach (var arg in arguments)
{
args.Add(arg);
}
}
constructor.Apply(context, args, namedArguments);
}
return(dynobj);
}
private void FinishSentence(ICoreMap sentence, IList <Tree> trees)
{
if (treeMap != null)
{
IList <Tree> mappedTrees = Generics.NewLinkedList();
foreach (Tree tree in trees)
{
Tree mappedTree = treeMap.Apply(tree);
mappedTrees.Add(mappedTree);
}
trees = mappedTrees;
}
ParserAnnotatorUtils.FillInParseAnnotations(Verbose, BuildGraphs, gsf, sentence, trees, extraDependencies);
if (saveBinaryTrees)
{
TreeBinarizer binarizer = TreeBinarizer.SimpleTreeBinarizer(parser.GetTLPParams().HeadFinder(), parser.TreebankLanguagePack());
Tree binarized = binarizer.TransformTree(trees[0]);
Edu.Stanford.Nlp.Trees.Trees.ConvertToCoreLabels(binarized);
sentence.Set(typeof(TreeCoreAnnotations.BinarizedTreeAnnotation), binarized);
}
// for some reason in some corner cases nodes aren't having sentenceIndex set
// do a pass and make sure all nodes have sentenceIndex set
SemanticGraph sg = sentence.Get(typeof(SemanticGraphCoreAnnotations.CollapsedDependenciesAnnotation));
if (sg != null)
{
foreach (IndexedWord iw in sg.VertexSet())
{
if (iw.Get(typeof(CoreAnnotations.SentenceIndexAnnotation)) == null && sentence.Get(typeof(CoreAnnotations.SentenceIndexAnnotation)) != null)
{
iw.SetSentIndex(sentence.Get(typeof(CoreAnnotations.SentenceIndexAnnotation)));
}
}
}
}
/// <summary>This method just tests the functionality of the included transformers.</summary>
public static void Main(string[] args)
{
//TreeFactory tf = new LabeledScoredTreeFactory();
Tree stringyTree = null;
try
{
stringyTree = (new PennTreeReader(new StringReader("(S (VP (VBZ Try) (NP (DT this))) (. .))"), new LabeledScoredTreeFactory(new StringLabelFactory()))).ReadTree();
}
catch (IOException)
{
}
// do nothing
System.Console.Out.WriteLine(stringyTree);
IFunction <Tree, Tree> a = GetLabeledTreeToCategoryWordTagTreeFunction();
Tree adaptyTree = a.Apply(stringyTree);
System.Console.Out.WriteLine(adaptyTree);
adaptyTree.PercolateHeads(new CollinsHeadFinder());
System.Console.Out.WriteLine(adaptyTree);
IFunction <Tree, Tree> b = GetLabeledTreeToStringLabeledTreeFunction();
Tree stringLabelTree = b.Apply(adaptyTree);
System.Console.Out.WriteLine(stringLabelTree);
}
public float[] Multiply(float[] vector, float[,] matrix, IFunction activationFunction)
{
activationFunction = activationFunction ?? new Linear();
var xLength = matrix.GetLength(0);
var yLength = matrix.GetLength(1);
if (vector.Length != xLength)
{
throw new ArgumentOutOfRangeException(nameof(vector), $"Vector length {vector.Length} doesn't correspond to matrix size [{xLength},{yLength}]");
}
var result = new float[yLength];
Parallel.For(0, yLength, y =>
{
for (int x = 0; x < xLength; x++)
{
result[y] += vector[x] * matrix[x, y];
}
result[y] = activationFunction.Apply(result[y]);
});
return(result);
}
public object Invoke(string name, IContext context, IList <object> arguments, IDictionary <string, object> namedArguments)
{
var value = this.GetValue(name);
IFunction method = value as IFunction;
if (method == null)
{
throw new TypeError(string.Format("'{0}' object is not callable", Types.GetTypeName(value)));
}
IList <object> args = new List <object>()
{
this
};
if (arguments != null && arguments.Count > 0)
{
foreach (var arg in arguments)
{
args.Add(arg);
}
}
return(method.Apply(context, args, namedArguments));
}
/// <summary>
/// Only works on English, as it is hard coded for using the
/// Morphology class, which is English-only
/// </summary>
public virtual IList <CoreLabel> Lemmatize <_T0>(IList <_T0> tokens)
where _T0 : IHasWord
{
IList <TaggedWord> tagged;
if (GetOp().testOptions.preTag)
{
IFunction <IList <IHasWord>, IList <TaggedWord> > tagger = LoadTagger();
tagged = tagger.Apply(tokens);
}
else
{
Tree tree = Parse(tokens);
tagged = tree.TaggedYield();
}
Morphology morpha = new Morphology();
IList <CoreLabel> lemmas = Generics.NewArrayList();
foreach (TaggedWord token in tagged)
{
CoreLabel label = new CoreLabel();
label.SetWord(token.Word());
label.SetTag(token.Tag());
morpha.Stem(label);
lemmas.Add(label);
}
return(lemmas);
}
/// <summary>
/// helper method to find the longest entity mention that is coreferent to an entity mention
/// after coref has been run...match an entity mention to a coref mention, go through all of
/// the coref mentions and find the one with the longest matching entity mention, return
/// that entity mention
/// </summary>
/// <param name="em">the entity mention of interest</param>
/// <param name="ann">the annotation, after coreference has been run</param>
/// <returns/>
public virtual Optional <ICoreMap> FindBestCoreferentEntityMention(ICoreMap em, Annotation ann)
{
// helper lambda
IFunction <Optional <ICoreMap>, int> lengthOfOptionalEntityMention = null;
// initialize return value as empty Optional
Optional <ICoreMap> bestCoreferentEntityMention = Optional.Empty();
// look for matching coref mention
int entityMentionIndex = em.Get(typeof(CoreAnnotations.EntityMentionIndexAnnotation));
Optional <int> matchingCorefMentionIndex = Optional.OfNullable(ann.Get(typeof(CoreAnnotations.EntityMentionToCorefMentionMappingAnnotation))[entityMentionIndex]);
Optional <Mention> matchingCorefMention = matchingCorefMentionIndex.IsPresent() ? Optional.Of(ann.Get(typeof(CorefCoreAnnotations.CorefMentionsAnnotation))[matchingCorefMentionIndex.Get()]) : Optional.Empty();
// if there is a matching coref mention, look at all of the coref mentions in its coref chain
if (matchingCorefMention.IsPresent())
{
Optional <CorefChain> matchingCorefChain = Optional.OfNullable(ann.Get(typeof(CorefCoreAnnotations.CorefChainAnnotation))[matchingCorefMention.Get().corefClusterID]);
IList <CorefChain.CorefMention> corefMentionsInTextualOrder = matchingCorefChain.IsPresent() ? matchingCorefChain.Get().GetMentionsInTextualOrder() : new List <CorefChain.CorefMention>();
foreach (CorefChain.CorefMention cm in corefMentionsInTextualOrder)
{
Optional <int> candidateCoreferentEntityMentionIndex = Optional.OfNullable(ann.Get(typeof(CoreAnnotations.CorefMentionToEntityMentionMappingAnnotation))[cm.mentionID]);
Optional <ICoreMap> candidateCoreferentEntityMention = candidateCoreferentEntityMentionIndex.IsPresent() ? Optional.OfNullable(ann.Get(typeof(CoreAnnotations.MentionsAnnotation))[candidateCoreferentEntityMentionIndex.Get()]) : Optional.Empty(
);
if (lengthOfOptionalEntityMention.Apply(candidateCoreferentEntityMention) > lengthOfOptionalEntityMention.Apply(bestCoreferentEntityMention))
{
bestCoreferentEntityMention = candidateCoreferentEntityMention;
}
}
}
return(bestCoreferentEntityMention);
}
public static IList <T> MergeListWithSortedMatched <T, _T1, _T2>(IList <_T1> list, IList <_T2> matched, IFunction <IList <T>, T> aggregator)
where _T1 : T
where _T2 : IHasInterval <int>
{
IList <T> merged = new List <T>(list.Count);
// Approximate size
int last = 0;
foreach (IHasInterval <int> m in matched)
{
Interval <int> interval = m.GetInterval();
int start = interval.GetBegin();
int end = interval.GetEnd();
if (start >= last)
{
Sharpen.Collections.AddAll(merged, list.SubList(last, start));
T t = aggregator.Apply(list.SubList(start, end));
merged.Add(t);
last = end;
}
}
// Add rest of elements
if (last < list.Count)
{
Sharpen.Collections.AddAll(merged, list.SubList(last, list.Count));
}
return(merged);
}
public static IList <T> MergeListWithSortedMatchedPreAggregated <T, _T1, _T2>(IList <_T1> list, IList <_T2> matched, IFunction <T, Interval <int> > toIntervalFunc)
where _T1 : T
where _T2 : T
{
IList <T> merged = new List <T>(list.Count);
// Approximate size
int last = 0;
foreach (T m in matched)
{
Interval <int> interval = toIntervalFunc.Apply(m);
int start = interval.GetBegin();
int end = interval.GetEnd();
if (start >= last)
{
Sharpen.Collections.AddAll(merged, list.SubList(last, start));
merged.Add(m);
last = end;
}
}
// Add rest of elements
if (last < list.Count)
{
Sharpen.Collections.AddAll(merged, list.SubList(last, list.Count));
}
return(merged);
}
public object Evaluate(Context context, bool withvars = false)
{
object modulevalue = this.moduleexpression.Evaluate(context, withvars);
object namevalue = this.nameexpression.Evaluate(context, withvars);
string modulename = ((Atom)modulevalue).Name;
string name = string.Format("{0}/{1}", ((Atom)namevalue).Name, this.argumentexpressions.Count);
IList <object> arguments = new List <object>();
foreach (var argexpr in this.argumentexpressions)
{
arguments.Add(argexpr.Evaluate(context, withvars));
}
Module module = context.GetValue(modulename) as Module;
if (module == null || !module.ExportNames.Contains(name) || !(module.Context.GetValue(name) is IFunction))
{
throw new Exception(string.Format("undefined function {0}:{1}", modulename, name));
}
IFunction func = (IFunction)module.Context.GetValue(name);
return(func.Apply(context, arguments));
}
/// <summary>
/// Adds all of the keys in <code>from</code> to <code>to</code>,
/// applying <code>function</code> to the values to transform them
/// from <code>V2</code> to <code>V1</code>.
/// </summary>
public static void AddAll <K, V1, V2>(IDictionary <K, V1> to, IDictionary <K, V2> from, IFunction <V2, V1> function)
{
foreach (KeyValuePair <K, V2> entry in from)
{
to[entry.Key] = function.Apply(entry.Value);
}
}
public virtual void Annotate(MatchedExpression matchedExpression)
{
IValue ev = null;
if (expressionToValue != null)
{
ev = expressionToValue.Apply(matchedExpression);
}
matchedExpression.value = (ev != null) ? ev : valueExtractor.Apply(matchedExpression.annotation);
if (resultAnnotationField != null)
{
if (resultAnnotationExtractor != null)
{
object result = resultAnnotationExtractor.Apply(matchedExpression);
SetAnnotations(matchedExpression.annotation, resultAnnotationField, result);
}
else
{
// TODO: Should default result be the matchedExpression, value, object???
//matchedExpression.annotation.set(resultAnnotationField, matchedExpression);
IValue v = matchedExpression.GetValue();
SetAnnotations(matchedExpression.annotation, resultAnnotationField, (v != null) ? v.Get() : null);
}
}
if (tokensResultAnnotationField != null)
{
IList <ICoreMap> tokens = (IList <ICoreMap>)matchedExpression.annotation.Get(tokensAnnotationField);
if (resultAnnotationExtractor != null)
{
object result = resultAnnotationExtractor.Apply(matchedExpression);
foreach (ICoreMap cm in tokens)
{
SetAnnotations(cm, tokensResultAnnotationField, result);
}
}
else
{
// TODO: Should default result be the matchedExpression, value, object???
//matchedExpression.annotation.set(resultAnnotationField, matchedExpression);
IValue v = matchedExpression.GetValue();
foreach (ICoreMap cm in tokens)
{
SetAnnotations(cm, tokensResultAnnotationField, (v != null) ? v.Get() : null);
}
}
}
}
/// <summary>
/// Adds all of the entries in the <code>other</code> map, performing
/// <code>function</code> on them to transform the values
/// </summary>
public virtual void AddAll <V2, _T1>(Edu.Stanford.Nlp.Util.TwoDimensionalMap <_T1> other, IFunction <V2, V> function)
where _T1 : K1
{
foreach (TwoDimensionalMap.Entry <K1, K2, V2> entry in other)
{
Put(entry.GetFirstKey(), entry.GetSecondKey(), function.Apply(entry.GetValue()));
}
}
/// <summary>
/// Returns a lexicalized Tree whose Labels are CategoryWordTag
/// instances, all corresponds to the input tree.
/// </summary>
public static Tree Lexicalize(Tree t, IHeadFinder hf)
{
IFunction <Tree, Tree> a = TreeFunctions.GetLabeledTreeToCategoryWordTagTreeFunction();
Tree t1 = a.Apply(t);
t1.PercolateHeads(hf);
return(t1);
}
public JToken Evaluate(JToken inputOptional, WalkedPath walkedPath, JObject context)
{
JToken valueOptional = null;
try
{
// "key": "@0", "key": literal
if (_function == null)
{
valueOptional = _functionArgs[0].EvaluateArg(walkedPath, context);
}
// "key": "=abs(@(1,&0))"
// this is most usual case, a single argument is passed and we need to evaluate and
// pass the value, if present, to the spec function
else if (_functionArgs.Length == 1)
{
var evaluatedArgValue = _functionArgs[0].EvaluateArg(walkedPath, context);
valueOptional = evaluatedArgValue != null?_function.Apply(evaluatedArgValue) : _function.Apply();
}
// "key": "=abs(@(1,&0),-1,-3)"
// this is more complicated case! if args is an array, after evaluation we cannot pass a missing value wrapped in
// object[] into function. In such case null will be passed however, in json null is also a valid value, so it is
// upto the implementer to interpret the value. Ideally we can almost always pass a list straight from input.
else if (_functionArgs.Length > 1)
{
var evaluatedArgs = EvaluateArgsValue(_functionArgs, context, walkedPath);
valueOptional = _function.Apply(evaluatedArgs);
}
//
// FYI this is where the "magic" happens that allows functions that take a single method
// default to the current "match" rather than an explicit "reference".
// Note, this does not work for functions that take more than a single input.
//
// "key": "=abs"
else
{
// pass current value as arg if present
valueOptional = inputOptional != null?_function.Apply(inputOptional) : _function.Apply();
}
}
catch (Exception)
{
}
return(valueOptional);
}
public virtual Tree TransformTree(Tree tree)
{
foreach (Tree leaf in tree.GetLeaves())
{
ILabel label = leaf.Label();
label.SetValue(transform.Apply(label.Value()));
}
return(tree);
}
public float[] ApplyFunction(float[] vector, IFunction activationFunction)
{
activationFunction = activationFunction ?? new Linear();
var result = new float[vector.Length];
Parallel.For(0, vector.Length, i => { result[i] = activationFunction.Apply(vector[i]); });
return(result);
}
// when we're inside a block to be transformed, we ignore
// elements that don't end the block.
public virtual void ProcessText(string text)
{
if (text.Length > 0)
{
text = function.Apply(text).ToString();
outWriter.Print(XMLUtils.EscapeXML(text));
outWriter.Print('\n');
}
}
/// <summary>
/// <inheritDoc/>
///
/// </summary>
public virtual ICollection <string> TagSet(IFunction <string, string> basicCategoryFunction)
{
ICollection <string> tagSet = new HashSet <string>();
foreach (string tag in tagIndex.ObjectsList())
{
tagSet.Add(basicCategoryFunction.Apply(tag));
}
return(tagSet);
}
/// <summary>
/// Makes it possible to uniquify a collection of objects which are normally
/// non-hashable.
/// </summary>
/// <remarks>
/// Makes it possible to uniquify a collection of objects which are normally
/// non-hashable. Alternatively, it lets you define an alternate hash function
/// for them for limited-use hashing.
/// </remarks>
public static ICollection <ObjType> UniqueNonhashableObjects <ObjType, Hashable>(ICollection <ObjType> objects, IFunction <ObjType, Hashable> customHasher)
{
IDictionary <Hashable, ObjType> hashesToObjects = Generics.NewHashMap();
foreach (ObjType @object in objects)
{
hashesToObjects[customHasher.Apply(@object)] = @object;
}
return(hashesToObjects.Values);
}
private float[] SigmaOut(float[] ideal, float[] input, IFunction activationFunction)
{
activationFunction = activationFunction ?? new Linear();
float[] sigmaOut = new float[input.Length];
Parallel.For(0, sigmaOut.Length, i => { sigmaOut[i] = (ideal[i] - activationFunction.Apply(input[i])) * activationFunction.Derevative(input[i]); });
return(sigmaOut);
}
/// <summary>
/// Will parse the text in <code>sentence</code> as if it represented
/// a single sentence by first processing it with a tokenizer.
/// </summary>
public virtual Tree Parse(string sentence)
{
IList <IHasWord> tokens = Tokenize(sentence);
if (GetOp().testOptions.preTag)
{
IFunction <IList <IHasWord>, IList <TaggedWord> > tagger = LoadTagger();
tokens = tagger.Apply(tokens);
}
return(Parse(tokens));
}
public virtual IFunction Evaluate(IList <IFunction> parameters)
{
IFunction result = this;
foreach (IFunction parameter in parameters)
{
result = result.Apply(parameter);
}
return(result);
}
public static IList <T> MergeList <T, M, _T2>(IList <_T2> list, ICollection <M> matched, IFunction <M, Interval <int> > toIntervalFunc, IFunction <IList <T>, T> aggregator)
where _T2 : T
{
IList <Interval <int> > matchedIntervals = new List <Interval <int> >(matched.Count);
foreach (M m in matched)
{
matchedIntervals.Add(toIntervalFunc.Apply(m));
}
return(MergeList(list, matchedIntervals, aggregator));
}
/// <summary>Transforms the keyset of collection according to the given Function and returns a list.</summary>
public static IList <T2> TransformAsList <T1, T2, _T2>(ICollection <_T2> original, IFunction <T1, T2> f)
where _T2 : T1
{
IList <T2> transformed = new List <T2>();
foreach (T1 t in original)
{
transformed.Add(f.Apply(t));
}
return(transformed);
}
/// <summary>Transforms the keyset of collection according to the given Function and returns a set of the keys.</summary>
public static ICollection <T2> TransformAsSet <T1, T2, _T2>(ICollection <_T2> original, IFunction <T1, T2> f)
where _T2 : T1
{
ICollection <T2> transformed = Generics.NewHashSet();
foreach (T1 t in original)
{
transformed.Add(f.Apply(t));
}
return(transformed);
}
public object Evaluate(ValueEnvironment environment)
{
IFunction function = (IFunction)Machine.Evaluate(this.first, environment);
if (function == null)
{
throw new InvalidOperationException(string.Format("Unknown form '{0}'", this.first.ToString()));
}
return(function.Apply(this.Next, environment));
}
public static IFunction <TIn, TOut> SelectMany <TIn, TMid1, TMid2, TOut>(
this IFunction <TIn, TMid1> func,
Func <TMid1, IFunction <TIn, TMid2> > proj1,
Func <TMid1, TMid2, TOut> proj2)
{
return(Create(x => {
var mid1 = func.Apply(x);
var mid2 = proj1(mid1).Apply(x);
return proj2(mid1, mid2);
}));
}
