private IEnumerable <NodeReference> evaluate(StructuredInterpretation interpretation, QuestionEvidence question)
{
HashSet <NodeReference> inputSet = null;
for (var i = 0; i < _generalFeatureNodes.Length; ++i)
{
var generalNode = _generalFeatureNodes[i];
var featureNode = question.GetFeatureNode(generalNode, Graph);
var constraint = interpretation.GetGeneralConstraint(i);
if (inputSet == null)
{
inputSet = constraint.FindSet(featureNode, Graph);
}
else
{
inputSet.IntersectWith(constraint.FindSet(featureNode, Graph));
}
}
var pool = new ContextPool(Graph);
pool.Insert(inputSet.ToArray());
foreach (var distinguishConstraint in interpretation.DisambiguationConstraints)
{
distinguishConstraint.Execute(pool);
}
return(pool.ActiveNodes);
}
private StructuredInterpretation getInterpretation(ConstraintSelector selector)
{
var constraints = selector.Rules;
var interpretation = new StructuredInterpretation(FeatureKey, _topicGenerator.TopicConstraints, constraints);
return(interpretation);
}
internal IEnumerable <NodeReference> Evaluate(string question, StructuredInterpretation structuredInterpretation)
{
var matchingCover = getMatchingCover(question, structuredInterpretation.FeatureKey);
var constraints = structuredInterpretation.GeneralConstraints.Zip(matchingCover.GetInstanceNodes
(Graph), Tuple.Create);
HashSet <NodeReference> topicNodes = null;
foreach (var constraint in constraints)
{
var constraintSet = constraint.Item1.FindSet(constraint.Item2, Graph);
if (topicNodes == null)
{
topicNodes = constraintSet;
}
else
{
topicNodes.IntersectWith(constraintSet);
}
}
var pool = new ContextPool(Graph);
pool.Insert(topicNodes.ToArray());
foreach (var constraint in structuredInterpretation.DisambiguationConstraints)
{
constraint.Execute(pool);
}
return(pool.ActiveNodes);
}
private Ranked <StructuredInterpretation> rank(StructuredInterpretation interpretation)
{
var evidenceScore = 0.0;
foreach (var question in _questions)
{
var answer = evaluate(interpretation, question.Value);
if (answer.Count() != 1)
{
//this is not good answer
continue;
}
var answerNode = answer.First();
evidenceScore += question.Value.GetEvidenceScore(answerNode);
}
evidenceScore += generalizationScore(interpretation);
return(new Ranked <StructuredInterpretation>(interpretation, evidenceScore));
}
private double generalizationScore(StructuredInterpretation interpretation)
{
HashSet <NodeReference> topicNodes = null;
for (var i = 0; i < _generalFeatureNodes.Length; ++i)
{
var generalNode = _generalFeatureNodes[i];
var constraint = interpretation.GetGeneralConstraint(i);
var nodeDomain = getInstanceDomain(generalNode);
var topicalizedDomain = getConstrainedLayer(nodeDomain, constraint);
if (topicNodes == null)
{
topicNodes = new HashSet <NodeReference>();
}
else
{
topicNodes.IntersectWith(nodeDomain);
}
}
var pool = new ContextPool(Graph);
pool.Insert(topicNodes.ToArray());
foreach (var constraint in interpretation.DisambiguationConstraints)
{
constraint.Execute(pool);
}
var topicNodesCount = topicNodes.Count + 1;
var generalizationBonus = 1.0 * pool.ActiveCount / topicNodesCount;
var generalizationRatio = 1 - 1.0 / topicNodesCount;
return(generalizationRatio * generalizationBonus);
}
