public Ranked <IEnumerable <NodeReference> > GetRankedAnswer(string question, ContextPool pool) { //keep original pool non-modified pool = pool.Clone(); var parsedQuestion = UtteranceParser.Parse(question); var covers = FeatureCover.GetFeatureCovers(parsedQuestion, Graph); var interpretations = _mapping.GetRankedInterpretations(covers); var bestMatch = interpretations.BestMatch; if (bestMatch.Value == null) { //no interpretation has been found return(new Ranked <IEnumerable <NodeReference> >(new NodeReference[0], 0.0)); } var bestInterpretation = bestMatch.Value.Item2.Interpretation; var bestCover = bestMatch.Value.Item1; var instantiatedInterpretation = bestInterpretation.InstantiateBy(bestCover, Graph); //run the interpretation on the pool Console.WriteLine("\n"); foreach (var rule in instantiatedInterpretation.Rules) { rule.Execute(pool); Console.WriteLine(rule); Console.WriteLine("POOL: " + string.Join(" ", pool.ActiveNodes)); } return(new Ranked <IEnumerable <NodeReference> >(pool.ActiveNodes, bestMatch.Rank)); }
internal Interpretation GeneralizeBy(FeatureCover cover, ComposedGraph graph) { var mapping = cover.CreateNodeMapping(graph); var isContractable = _rules.Any(r => r is InsertPoolRule); if (mapping.IsEmpty) { //there is nothing to generalize if (isContractable) { //contractable interpretation without generalization is trivial return(null); } else { return(this); } } mapping.IsGeneralizeMapping = true; var newRules = mapRules(mapping); if (!mapping.WasUsed && isContractable) { //mapping wasnt used, so the contractable interpretation is trivial return(null); } return(new Interpretation(newRules)); }
internal IEnumerable <Ranked <ContextRuleMapping> > GetRankedMappings(FeatureCover cover) { var distributions = getDistributions(cover); var currentLayer = new List <RuleChain>(); var newLayer = new List <RuleChain>(); //compute chains of distributions in layers currentLayer.Add(new RuleChain()); foreach (var distribution in distributions) { for (var ruleIndex = 0; ruleIndex < distribution.Size; ++ruleIndex) { if (distribution == null) { throw new NotImplementedException("What to do, when distribution is not available?"); } var rule = distribution.GetRule(ruleIndex); var probability = distribution.GetProbability(ruleIndex); foreach (var ruleChain in currentLayer) { newLayer.Add(ruleChain.ExtendBy(rule, probability)); } } //efficiently swap layers var swappedLayer = currentLayer; currentLayer = newLayer; newLayer = swappedLayer; newLayer.Clear(); } throw new NotImplementedException("Select only valid rules"); }
/// <summary> /// Negation evidence on question's answer. /// </summary> /// <param name="question">The adviced question.</param> /// <param name="negatedAnswer">The negated answer.</param> public void Negate(FeatureCover question, NodeReference negatedAnswer) { var evidence = getQuestionEvidence(question); evidence.Negate(negatedAnswer); checkInterpretationUpdates(); }
/// <summary> /// Gives advice about answer on the question. /// </summary> /// <param name="question">The adviced question.</param> /// <param name="answer">The adviced answer.</param> public void Advice(FeatureCover question, NodeReference answer) { var evidence = getQuestionEvidence(question); evidence.Advice(answer); checkInterpretationUpdates(); }
internal void AddInterpretation(FeatureCover cover, RuledInterpretation interpretation, double rank) { double score; var key = Tuple.Create(cover, interpretation); _interpretationScores.TryGetValue(key, out score); score += rank; _interpretationScores[key] = score; }
internal void AdviceAnswer(string question, NodeReference answer) { var parsedQuestion = UtteranceParser.Parse(question); foreach (var featureCover in FeatureCover.GetFeatureCovers(parsedQuestion, Graph)) { register(featureCover, answer); } }
/// <summary> /// Gets evidence for given question. /// </summary> /// <param name="question">The question.</param> /// <returns>The evidence.</returns> private QuestionEvidence getQuestionEvidence(FeatureCover question) { QuestionEvidence evidence; if (!_questions.TryGetValue(question.OriginalUtterance, out evidence)) { _questions[question.OriginalUtterance] = evidence = new QuestionEvidence(question); } return(evidence); }
internal Ranked <RuledInterpretation> GetRankedInterpretation(FeatureCover cover) { InterpretationCounter counter; if (!_coverIndex.TryGetValue(cover.FeatureKey, out counter)) { return(null); } return(new Ranked <RuledInterpretation>(counter.BestInterpretation, counter.BestCount)); }
private RulesDistribution[] getDistributions(FeatureCover cover) { var distributions = new List <RulesDistribution>(); foreach (var instance in cover.FeatureInstances) { RulesDistribution distribution; _featureToDistributions.TryGetValue(instance.Feature, out distribution); distributions.Add(distribution); } return(distributions.ToArray()); }
private FeatureEvidence getEvidence(FeatureCover cover) { FeatureEvidence evidence; var key = cover.FeatureKey; if (!_featureEvidences.TryGetValue(key, out evidence)) { _featureEvidences[key] = evidence = new FeatureEvidence(cover, Graph); _featureIndex.Add(key); } return(evidence); }
private FeatureCover getMatchingCover(string question, FeatureKey key) { var parsedQuestion = UtteranceParser.Parse(question); foreach (var cover in FeatureCover.GetFeatureCovers(parsedQuestion, Graph)) { if (key.Equals(cover.FeatureKey)) { return(cover); } } return(null); }
internal NodeReference GetAnswer(ParsedUtterance expression) { var covers = FeatureCover.GetFeatureCovers(expression, Graph); var allRankedMappings = new List <Ranked <ContextRuleMapping> >(); foreach (var cover in covers) { var rankedMappings = _mapping.GetRankedMappings(cover); allRankedMappings.AddRange(rankedMappings); } throw new NotImplementedException(); }
protected override bool adviceAnswer(string question, bool isBasedOnContext, NodeReference correctAnswerNode, IEnumerable <NodeReference> context) { var parsedQuestion = UtteranceParser.Parse(question); var interpretationsFactory = getInterpretationsFactory(parsedQuestion, isBasedOnContext, correctAnswerNode, context); var covers = FeatureCover.GetFeatureCovers(parsedQuestion, Graph); _mapping.Add(interpretationsFactory, covers); //TODO decide whether it would be benefitial to report that //the advice is taken into account, however we don't believe it much. return(true); }
internal Interpretation InstantiateBy(FeatureCover cover, ComposedGraph graph) { var mapping = cover.CreateNodeMapping(graph); if (mapping.IsEmpty) { return(this); } mapping.IsGeneralizeMapping = false; var newRules = mapRules(mapping); return(new Interpretation(newRules)); }
internal IEnumerable <FeatureEvidence> GetEvidences(string question) { var result = new List <FeatureEvidence>(); var parsedQuestion = UtteranceParser.Parse(question); foreach (var featureCover in FeatureCover.GetFeatureCovers(parsedQuestion, Graph)) { if (_featureEvidences.ContainsKey(featureCover.FeatureKey)) { result.Add(_featureEvidences[featureCover.FeatureKey]); } } return(result); }
private FeatureBase getBestFeature(RulePart rulePart, FeatureCover cover) { FeatureInstance bestFeatureInstance = null; var bestPMI = double.NegativeInfinity; foreach (var featureInstance in cover.FeatureInstances) { //select best feature according to pointwise mutual information var featurePMI = getPointwiseMutualInformation(rulePart, featureInstance.Feature); if (featurePMI > bestPMI) { bestPMI = featurePMI; bestFeatureInstance = featureInstance; } } return(bestFeatureInstance.Feature); }
private Ranked <ContextRuleMapping> getRankedMapping(FeatureCover cover, Ranked <Interpretation> rankedInterpretation) { var ruleDecomposition = createInterpretationDecompositions(rankedInterpretation.Value); //assign rule parts to features var assignments = new Dictionary <RulePart, FeatureBase>(); foreach (var rulePart in ruleDecomposition.Parts) { var bestFeature = getBestFeature(rulePart, cover); assignments[rulePart] = bestFeature; } var rankedMapping = createRankedContextRuleMapping(assignments); //rerank with interpretation ranking var rerankedMapping = new Ranked <ContextRuleMapping>(rankedMapping.Value, rankedMapping.Rank * rankedInterpretation.Rank); return(rerankedMapping); }
private void reportToCompatibleGenerators(FeatureCover reportingCover, Interpretation generalInterpretation) { if (_completedGeneralInterpretations.Contains(generalInterpretation)) { //we are searchnig only for new general interpretations return; } //remember that we have proceed this interpretation so we don't need to repeatedly increment it _completedGeneralInterpretations.Add(generalInterpretation); //feature key has always been present in the index var generatorCovers = _keyToGeneratorCovers[reportingCover.FeatureKey]; var compatibleCovers = new List <FeatureCover>(); foreach (var generatorCover in generatorCovers) { var generator = generatorCover.Item1; var cover = generatorCover.Item2; var instantiatedInterpretation = generalInterpretation.InstantiateBy(cover, Graph); if (isCompatibleInterpretation(instantiatedInterpretation, generator)) { compatibleCovers.Add(cover); var ruledInterpretation = new RuledInterpretation(generalInterpretation, reportingCover.FeatureKey); _mapping.ReportInterpretation(ruledInterpretation); } } if (compatibleCovers.Count > 1) { Console.WriteLine(generalInterpretation); Console.WriteLine("\tCOMPATIBLE WITH:"); foreach (var cover in compatibleCovers) { var origin = cover.FeatureInstances.First().Origin; Console.WriteLine("\t\t" + origin); } Console.WriteLine(); } }
protected override bool adviceAnswer(string question, bool isBasedOnContext, NodeReference correctAnswerNode, IEnumerable <NodeReference> context) { var parsedQuestion = UtteranceParser.Parse(question); var covers = FeatureCover.GetFeatureCovers(parsedQuestion, Graph); //setup interpretation generator var factory = new InterpretationsFactory(parsedQuestion, isBasedOnContext, correctAnswerNode); var contextPool = new ContextPool(Graph); contextPool.Insert(context.ToArray()); var generator = new InterpretationGenerator(covers, factory, contextPool, this); //!!!!!!!!!!!!!!TODOOOOOOOOOOOOO!!!!!!!!!!!!!! //We have to check compatibility of the generator with all known interpretations _interpretationGenerators.Add(generator); //register covers according to its feature keys foreach (var cover in generator.Covers) { List <Tuple <InterpretationGenerator, FeatureCover> > generators; if (!_keyToGeneratorCovers.TryGetValue(cover.FeatureKey, out generators)) { _keyToGeneratorCovers[cover.FeatureKey] = generators = new List <Tuple <InterpretationGenerator, FeatureCover> >(); } generators.Add(Tuple.Create(generator, cover)); } //TODO decide whether it would be benefitial to report that //the advice is taken into account, however we don't believe it much. //TODO initialize with first interpretation? return(true); }
internal QuestionEvidence(FeatureCover questionCover) { Cover = questionCover; Question = questionCover.OriginalUtterance; }
private void register(FeatureCover cover, NodeReference answer) { var evidence = getEvidence(cover); evidence.Advice(cover, answer); }
internal FeatureEvidence(FeatureCover cover, ComposedGraph graph) { Graph = graph; FeatureKey = cover.FeatureKey; _generalFeatureNodes = cover.GetGeneralNodes(graph).ToArray(); }
private IEnumerable <Interpretation> getGeneralInterpretations(Interpretation interpretation, FeatureCover reportingCover) { var generalInterpretation = interpretation.GeneralizeBy(reportingCover, Graph); if (generalInterpretation != null) { //report interpretation as is yield return(generalInterpretation); yield break; } foreach (var extendedInterpretation in interpretation.ExtendBy(reportingCover.GetInstanceNodes(Graph), Graph)) { var generalExtendedInterpretation = extendedInterpretation.GeneralizeBy(reportingCover, Graph); if (generalExtendedInterpretation == null) { throw new NotSupportedException("generalization should be successful"); } yield return(generalExtendedInterpretation); } }