protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var subject = generator.GetValue(instance, Concept2.Subject); var property = generator.GetValue(instance, Concept2.Property); var inheritedProperties = generator.GetPropertyValues(subject, includeInstanceProps: false); var value = generator.GetValue(subject, property.Concept); if (value == null) { var refutation = new ConceptInstance(Concept2.KnowledgeRefutation); var refutedInfo = new ConceptInstance(subject.Concept); generator.SetValue(refutedInfo, property.Concept, new ConceptInstance(Concept2.Something)); generator.SetValue(refutation, Concept2.Subject, refutedInfo); generator.SetValue(refutation, Concept2.Property, property); generator.Push(new InstanceOutputEvent(refutation)); } else { var confirmation = new ConceptInstance(Concept2.KnowledgeConfirmed); var confirmedInfo = new ConceptInstance(subject.Concept); generator.SetValue(confirmedInfo, property.Concept, value); generator.SetValue(confirmation, Concept2.Subject, confirmedInfo); generator.Push(new InstanceOutputEvent(confirmation)); } }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var property = generator.GetValue(instance, _propertyParameter); var subject = generator.GetValue(instance, _subjectParameter); var answer = getAnswer(subject, property.Concept, generator); if (answer.Count == 0) { //generator.Push(new StaticScoreEvent(-0.20)); generator.Push(new InstanceOutputEvent(new ConceptInstance(Concept2.NotFound))); } else if (answer.Count == 1) { generator.Push(new StaticScoreEvent(0.20)); generator.Push(new InstanceOutputEvent(answer.First())); } else { var needRefinementInstance = new ConceptInstance(Concept2.NeedsRefinement); generator.SetValue(needRefinementInstance, Concept2.Subject, subject); generator.SetValue(subject, Concept2.OnSetListener, instance); generator.Push(new InstanceOutputEvent(needRefinementInstance)); } }
protected override IEnumerable <string> execute(BeamGenerator generator) { var unknownPhrases = GetUnknownPhrases(generator); var isInLearnPhraseMode = PreviousPolicy <LearnNewPhrase>(out var learnPolicy) || PreviousPolicy <UnknownAnsweredToLearnNewPhrase>(out learnPolicy); if (!isInLearnPhraseMode || unknownPhrases.Count() != 1) { yield break; } var unknown = generator.GetValue(learnPolicy.Tag, Concept2.Unknown); var prompt = generator.GetValue(learnPolicy.Tag, Concept2.Prompt); //remember runtime info so others can use it generator.SetValue(TagInstance, Concept2.Unknown, unknown); generator.SetValue(TagInstance, Concept2.Prompt, prompt); generator.Push(new InstanceActivationRequestEvent(prompt)); yield return($"Still, I'm not getting it. What does {singular(unknown)} mean?"); yield return($"That is complicated. What does {singular(unknown)} mean?"); yield return($"I don't know those words. Could you put {singular(unknown)} differently?"); }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var subject = generator.GetValue(instance, Concept2.Subject); var target = generator.GetValue(instance, Concept2.Target); var relevantProperties = getRelevantProperties(target, generator); if (!relevantProperties.Any()) { generator.Push(new StaticScoreEvent(-0.5)); return; } var disambiguation = new ConceptInstance(Concept2.PropertyValueDisambiguation); generator.SetValue(disambiguation, Concept2.Unknown, subject); generator.SetValue(disambiguation, Concept2.Target, target); foreach (var pair in relevantProperties) { var propertyInstance = new ConceptInstance(pair.Key); foreach (var value in pair.Value) { var valueInstance = new ConceptInstance(value); generator.SetValue(valueInstance, Concept2.Property, propertyInstance); generator.SetValue(disambiguation, Concept2.Subject, valueInstance); } } generator.Push(new InstanceActivationRequestEvent(disambiguation)); }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var subjects = generator.GetValues(instance, Concept2.Subject).ToArray(); var answer = generator.GetValue(instance, Concept2.Answer); var unknown = generator.GetValue(instance, Concept2.Unknown); var target = generator.GetValue(instance, Concept2.Target); var directSubjects = filterDirectSubjects(subjects, answer); var indirectSubjects = filterIndirectSubjects(subjects, answer, generator); if (answer.Concept == Concept2.Nothing) { // user does not like any option return; } if (directSubjects.Count() == 1) { pushSetSubject(target, directSubjects.First(), generator, unknown); return; } if (indirectSubjects.Count() == 1) { pushSetSubject(target, indirectSubjects.First(), generator, unknown); return; } if (indirectSubjects.Count() == 0) { generator.Push(new InstanceOutputEvent(new ConceptInstance(Concept2.DisambiguationFailed))); return; } if (indirectSubjects.Count() < subjects.Count()) { //create new disambiguation generator.Push(new StaticScoreEvent(0.1)); pushNewDisambiguation(indirectSubjects, unknown, target, generator); return; } if (indirectSubjects.Count() == subjects.Count()) { var knowledgeConfirmation = new ConceptInstance(Concept2.DisambiguatedKnowledgeConfirmed); generator.SetValue(knowledgeConfirmation, Concept2.Subject, answer); generator.SetValue(knowledgeConfirmation, Concept2.Target, instance); generator.Push(new StaticScoreEvent(0.05)); generator.Push(new InstanceOutputEvent(knowledgeConfirmation)); return; } //disambiguation was not helpful generator.Push(new StaticScoreEvent(-1.0)); }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var property = generator.GetValue(instance, Concept2.Property); var target = generator.GetValue(instance, Concept2.Target); var setTarget = new PropertySetTarget(target, Concept2.HasProperty); var evt = new PropertySetEvent(setTarget, property, allowActivation: false); generator.Push(evt); generator.Push(new ExportEvent(evt)); }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var subject = generator.GetValue(instance, Concept2.Subject); var description = generator.GetValue(instance, Concept2.Description); var conceptDescription = new ConceptDescriptionEvent(subject.Concept, description.Concept.Name); var export = new ExportEvent(conceptDescription); generator.Push(export); generator.Push(conceptDescription); }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var unknown = generator.GetValue(instance, Concept2.Unknown); var answer = generator.GetValue(instance, Concept2.Answer).Concept; if (answer == Concept2.Nothing || answer == Concept2.No || answer == Concept2.Nothing) { //nothing to report } else { generator.Push(new InstanceOutputEvent(instance)); } }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var parameterValue = generator.GetValue(instance, _parameter); var relevantInstances = getRelevantInstances(instance, parameterValue.Concept, generator).ToArray(); foreach (var relevantInstance in relevantInstances) { //avoid reference circles if (relevantInstance.Concept == instance.Concept) { continue; } if (!generator.IsDefined(relevantInstance.Concept)) { continue; } //try tunnel instances between turns generator.Push(new StaticScoreEvent(0.05)); generator.Push(new InstanceReferencedEvent(relevantInstance)); generator.Pop(); generator.Pop(); } }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var target = generator.GetValue(instance, Concept2.Target); var targetProperty = generator.GetValue(instance, Concept2.TargetProperty); var subject = generator.GetValue(instance, Concept2.Subject); var generalTarget = new PropertySetTarget(target.Concept, targetProperty.Concept); var setEvent = new PropertySetEvent(generalTarget, subject); generator.Push(new ExportEvent(setEvent)); generator.Push(setEvent); if (generator.IsDefined(instance.Concept)) { generator.Push(new InstanceOutputEvent(instance)); } }
protected override IEnumerable <string> execute(BeamGenerator generator) { var evt = Get <InstanceOutputEvent>(); if (evt?.Instance.Concept != Concept2.NeedsRefinement) { yield break; } var instanceToRefine = generator.GetValue(evt.Instance, Concept2.Subject); var activationTarget = generator.GetValue(evt.Instance, Concept2.Target); var prefixesForRefine = generator.GetPrefixingUnknowns(instanceToRefine); if (!prefixesForRefine.TryGetValue(instanceToRefine, out var propertyUnknownRaw)) { //nothing to ask for yield break; } var propertyUnknown = toMeaningfulPhrase(propertyUnknownRaw); if (propertyUnknown == "") { yield break; } /* * //TODO feature based questions * * //ACTION SEQUENCE * //Do you want X which is UNKNOWN ? * Prompt * //-yes: what property UNKNOWN is ? * yes -> expect (properties) * //-- expect property * * //-no: So which X you want ? * no -> ? * //--standard refinement * * * yield return $"I know many {plural(instanceToRefine)} which one would you like?";*/ var assignUnknownProperty = AssignUnknownProperty.Create(instanceToRefine, propertyUnknown, generator); YesNoPrompt.Generate(generator, assignUnknownProperty, instanceToRefine); yield return($"So, you would like to find {plural(instanceToRefine)} which are {propertyUnknown}?"); }
private void pushSetSubject(ConceptInstance target, ConceptInstance resolvedSubject, BeamGenerator generator, ConceptInstance unknown) { RememberConceptDescription.Activate(resolvedSubject.Concept, unknown.Concept.Name, generator); var relevantProperty = generator.GetValue(resolvedSubject, Concept2.Property); generator.Push(new StaticScoreEvent(0.1)); generator.SetValue(target, relevantProperty.Concept, resolvedSubject); }
protected override IEnumerable <string> execute(BeamGenerator generator) { var evt = Get <InstanceOutputEvent>(i => i.Instance.Concept == Concept2.LearnNewConcept); if (evt == null) { yield break; } var collection = evt.Instance; var answer = generator.GetValue(collection, Concept2.Answer); var unknown = generator.GetValue(collection, Concept2.Unknown); var rememberDescription = RememberConceptDescription.Create(generator, answer.Concept, unknown.Concept.Name); YesNoPrompt.Generate(generator, rememberDescription, new ConceptInstance(Concept2.Nothing)); yield return($"So you think {singular(unknown)} is {singular(answer)} ?"); }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var answer = generator.GetValue(instance, Concept2.Answer).Concept; if (answer == Concept2.Yes) { var yesInstance = generator.GetValue(instance, Concept2.Yes); generator.Push(new InstanceActivationRequestEvent(yesInstance)); } else if (answer == Concept2.No) { var noInstance = generator.GetValue(instance, Concept2.No); generator.Push(new InstanceActivationRequestEvent(noInstance)); } else { generator.Push(new StaticScoreEvent(-1)); } }
protected override IEnumerable <string> execute(BeamGenerator generator) { var request = Get <IncompleteRelationEvent>(p => !p.IsFilled); if (request == null || request.Subject == null) { yield break; } var instanceConcept = request.Subject?.Concept; if (instanceConcept.Name == "the" || instanceConcept.Name == "a") { yield break; } if (instanceConcept == Concept2.What) { var subject = generator.GetValue(request.Subject, Concept2.Subject); var property = generator.GetValue(request.Subject, Concept2.Property); generator.Push(request); if (subject == null && property != null) { yield return($"{singular(property)} of what ?"); } else if (property == null && subject != null) { yield return($"What are you interested in about {singular(subject)} ?"); } else { yield return("What are you interested in?"); } } else { generator.Push(request); yield return("What should I " + singular(request.Subject) + " ?"); } }
protected override IEnumerable <string> execute(BeamGenerator generator) { var evt = Get <IncompleteRelationEvent>(s => !s.IsFilled && s.Subject?.Concept == Concept2.PropertyValueDisambiguation, searchInsideTurnOnly: false); if (evt == null) { yield break; } generator.Push(evt); var disambiguation = evt.Subject; var unknown = generator.GetValue(disambiguation, Concept2.Unknown); var candidates = generator.GetValues(disambiguation, Concept2.Subject); var candidateProperties = new HashSet <Concept2>(); foreach (var candidate in candidates) { var relevantProperty = generator.GetValue(candidate, Concept2.Property); candidateProperties.Add(relevantProperty.Concept); } if (candidateProperties.Count == 1) { var candidateString = string.Join(", ", candidates.Select(c => singular(c.Concept))); yield return($"I can recognize {candidateString} as {plural(candidateProperties.First())}. Which of them is related to {singular(unknown)}?"); } else if (candidateProperties.Count < 4) { var candidateString = string.Join(" or ", candidateProperties.Select(c => singular(c))); yield return($"What does {singular(unknown)} mean?"); yield return($"I think, It can be {candidateString}. Which fits best the meaning of {singular(unknown)}?"); } else { yield return($"What does {singular(unknown)} mean ?"); } }
private List <ConceptInstance> getAnswer(ConceptInstance subject, Concept2 property, BeamGenerator generator) { var result = new List <ConceptInstance>(); var directValue = generator.GetValue(subject, property); if (directValue != null) { result.Add(directValue); return(result); } var criterionValues = generator.GetPropertyValues(subject); criterionValues.Remove(Concept2.OnSetListener); // TODO internal property removal should be done in more systematic way var requiredProperties = new HashSet <Concept2>(criterionValues.Values.Select(i => i.Concept)); requiredProperties.Add(subject.Concept); var relevantConcepts = FindProvider.FindRelevantConcepts(generator, requiredProperties); foreach (var concept in relevantConcepts) { var searchedPropertyValue = generator.GetValue(concept, property); if (searchedPropertyValue == null) { continue; } result.Add(searchedPropertyValue); } return(result); }
protected override IEnumerable <string> execute(BeamGenerator generator) { //we are searching for deactivated instances because after call instance is deactivated var rememberAbility = FindDeactivatedTurnInstances(i => i.Concept == Concept2.RememberConceptDescription).FirstOrDefault(); if (rememberAbility == null) { yield break; } var subject = generator.GetValue(rememberAbility, Concept2.Subject); generator.Push(new Events.InstanceReferencedEvent(subject)); yield return($"Thank you. What should I do with {singular(subject)}?"); }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var answer = generator.GetValue(instance, Concept2.Answer); var options = generator.GetValues(instance, Concept2.Option); var disambiguatedOptions = disambiguate(options, answer); if (disambiguatedOptions.Count() == 1) { var activeOption = disambiguatedOptions.First(); var instanceToActivate = generator.GetValue(activeOption, Concept2.Invocation); generator.Push(new StaticScoreEvent(0.1)); generator.Push(new InstanceActivationRequestEvent(instanceToActivate)); } else if (disambiguatedOptions.Count() == 0) { generator.Push(new StaticScoreEvent(-0.2)); //push same options again pushNewOptions(options, generator); } else { pushNewOptions(disambiguatedOptions, generator); } }
private IEnumerable <ConceptInstance> filterIndirectSubjects(ConceptInstance[] subjects, ConceptInstance answer, BeamGenerator generator) { var result = new List <ConceptInstance>(); foreach (var subject in subjects) { var propertyInfo = generator.GetValue(subject, Concept2.Property); if (propertyInfo.Concept == answer.Concept) { result.Add(subject); } } return(result); }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var criterion = generator.GetValue(instance, _parameter); var criterionValues = generator.GetPropertyValues(criterion); criterionValues.Remove(Concept2.OnSetListener); // TODO internal property removal should be done in more systematic way criterionValues.Remove(Concept2.HasProperty); criterionValues.Remove(Concept2.HasPropertyValue); var requiredProperties = new HashSet <Concept2>(criterionValues.Values.Select(i => i.Concept)); requiredProperties.Add(criterion.Concept); var result = FindRelevantConcepts(generator, requiredProperties); var isSubjectClass = generator.GetInverseConceptValues(Concept2.InstanceOf, criterion).Any(); if (result.Count == 0) { if (isSubjectClass) { generator.Push(new StaticScoreEvent(0.1)); } else { generator.Push(new StaticScoreEvent(-0.1)); } generator.Push(new InstanceOutputEvent(new ConceptInstance(Concept2.NotFound))); } else if (result.Count == 1) { generator.Push(new StaticScoreEvent(0.5)); generator.Push(new InstanceOutputEvent(result.First())); } else { if (generator.IsProperty(criterion.Concept)) { generator.Push(new StaticScoreEvent(-0.15)); } var needRefinementInstance = new ConceptInstance(Concept2.NeedsRefinement); generator.SetValue(needRefinementInstance, Concept2.Subject, criterion); generator.SetValue(criterion, Concept2.OnSetListener, instance); generator.Push(new InstanceOutputEvent(needRefinementInstance)); } }
protected override IEnumerable <string> execute(BeamGenerator generator) { var unknownPhrases = GetUnknownPhrases(generator); if (!PreviousPolicy <RequestRefinement>(out var refinementPolicy) || unknownPhrases.Count() != 1) { yield break; } var instanceToRefine = generator.GetValue(refinementPolicy.Tag, Concept2.Target); var unknown = unknownPhrases.First(); var assignUnknownProperty = AssignUnknownProperty.Create(instanceToRefine, unknown, generator); YesNoPrompt.Generate(generator, assignUnknownProperty, instanceToRefine); yield return($"I suppose, you would like to find {plural(instanceToRefine)} which are {unknown}?"); }
protected override IEnumerable <string> execute(BeamGenerator generator) { var evt = Find <IncompleteRelationEvent>(s => !s.IsFilled && s.Subject?.Concept == Concept2.AssignUnknownProperty, precedingTurns: 1); if (evt == null) { yield break; } var disambiguation = evt.Subject; var unknown = generator.GetValue(disambiguation, Concept2.Unknown); // retry the event generator.Push(evt); yield return($"I'm sorry, I don't understand that either. What does {singular(unknown)} mean?"); yield return($"It seems to be very complicated. What does {singular(unknown)} mean?"); }
protected override void onInstanceActivated(ConceptInstance instance, BeamGenerator generator) { var subject = generator.GetValue(instance, Concept2.Subject); var inheritedProperties = generator.GetPropertyValues(subject, includeInstanceProps: false); var pureInstanceProperties = generator.GetPropertyValues(subject, includeInheritedProps: false); if (!pureInstanceProperties.Any()) { var confirmation = new ConceptInstance(Concept2.KnowledgeConfirmed); generator.SetValue(confirmation, Concept2.Subject, subject); generator.Push(new InstanceOutputEvent(confirmation)); return; } var unknown = new List <KeyValuePair <Concept2, ConceptInstance> >(); foreach (var propertyValue in pureInstanceProperties) { if (!inheritedProperties.TryGetValue(propertyValue.Key, out var knownValue) || knownValue.Concept != propertyValue.Value.Concept) { unknown.Add(propertyValue); } } if (unknown.Count == 0) { var confirmation2 = new ConceptInstance(Concept2.KnowledgeConfirmed); generator.SetValue(confirmation2, Concept2.Subject, subject); generator.Push(new InstanceOutputEvent(confirmation2)); return; } var unknownReport = new ConceptInstance(subject.Concept); foreach (var propertyValue in unknown) { generator.SetValue(unknownReport, propertyValue.Key, propertyValue.Value); } var confirmation3 = new ConceptInstance(Concept2.KnowledgeRefutation); generator.SetValue(confirmation3, Concept2.Subject, subject); generator.Push(new InstanceOutputEvent(unknownReport)); }
protected override IEnumerable <string> execute(BeamGenerator generator) { var evt = Get <InstanceOutputEvent>(); var priorityEvt = Get <InstanceOutputEvent>(p => p.Instance.Concept != Concept2.NeedsRefinement && p.Instance.Concept != Concept2.NotFound); if (priorityEvt != null || evt?.Instance.Concept != Concept2.NeedsRefinement) { yield break; } var instanceToRefine = generator.GetValue(evt.Instance, Concept2.Subject); // let following policies know about the refinement target generator.SetValue(TagInstance, Concept2.Target, instanceToRefine); // generate a question generator.Push(new IncompleteRelationEvent(instanceToRefine, Concept2.Something, null)); yield return($"I know many {plural(instanceToRefine)} which one would you like?"); }
private Dictionary <Concept2, HashSet <Concept2> > getRelevantProperties(ConceptInstance targetInstance, BeamGenerator generator) { var properties = new Dictionary <Concept2, HashSet <Concept2> >(); var definedConcepts = new HashSet <Concept2>(generator.GetDefinedConcepts()); foreach (var conceptCandidate in definedConcepts) { var conceptCandidateInstance = new ConceptInstance(conceptCandidate); var instanceOf = generator.GetValue(conceptCandidateInstance, Concept2.InstanceOf); if (conceptCandidate != targetInstance.Concept && instanceOf?.Concept != targetInstance.Concept) { continue; } var instanceProperties = generator.GetPropertyValues(conceptCandidateInstance); foreach (var instanceProperty in instanceProperties) { if (!definedConcepts.Contains(instanceProperty.Value.Concept)) { continue; } if (!definedConcepts.Contains(instanceProperty.Key)) { continue; } if (!properties.TryGetValue(instanceProperty.Key, out var propertyValues)) { properties[instanceProperty.Key] = propertyValues = new HashSet <Concept2>(); } propertyValues.Add(instanceProperty.Value.Concept); } } return(properties); }
protected override IEnumerable <string> execute(BeamGenerator generator) { var askedForLearning = PreviousPolicy <LearnNewPhrase>(out var policyTag) || PreviousPolicy <UnknownAnsweredToLearnNewPhrase>(out policyTag); if (!askedForLearning) { yield break; } var instances = FindTurnInstances().ToArray(); if (!instances.Any()) { yield break; } var unknown = generator.GetValue(policyTag.Tag, Concept2.Unknown); var hypothesis = instances.Last(); generator.Push(new StaticScoreEvent(0.1)); YesNoPrompt.Generate(generator, RememberConceptDescription.Create(generator, hypothesis.Concept, unknown.Concept.Name), new ConceptInstance(Concept2.Nothing)); yield return($"So, you think that {singular(unknown)} means {singular(hypothesis)} ?"); }
private ConceptInstance getProperty(ConceptInstance instance, Concept2 property) { return(BeamGenerator.GetValue(instance, property, _processedNode)); }
protected override IEnumerable <string> execute(BeamGenerator generator) { var suppressedConcepts = new HashSet <Concept2> { Concept2.NotFound, Concept2.DisambiguatedKnowledgeConfirmed, Concept2.NeedsRefinement }; var evt = Get <InstanceOutputEvent>(); var priorityEvt = Get <InstanceOutputEvent>(p => !suppressedConcepts.Contains(p.Instance.Concept)); if (priorityEvt != null) { evt = priorityEvt; } if (evt == null) { yield break; } var concept = evt.Instance.Concept; generator.SetValue(TagInstance, Concept2.Subject, evt.Instance); if (concept == Concept2.DisambiguatedKnowledgeConfirmed) { var disamb = Find <IncompleteRelationEvent>(s => !s.IsFilled && s.Subject?.Concept == Concept2.PropertyValueDisambiguation, precedingTurns: 1); var confirmed = generator.GetValue(evt.Instance, Concept2.Subject); var disambiguator = generator.GetValue(evt.Instance, Concept2.Target); generator.Push(new IncompleteRelationEvent(disambiguator, Concept2.Answer, null)); yield return($"I know it is {singular(confirmed)} already. Could you be more specific?"); } else if (concept == Concept2.NotFound) { yield return($"I don't know anything like that."); } else if (concept == Concept2.DisambiguationFailed) { yield return($"It is too complex for me. Could you use different words?"); } else if (concept == Concept2.RememberPropertyValue) { yield return($"Ok, I'll remember that."); yield return($"Thank you for the information!"); } else if (concept == Concept2.KnowledgeConfirmed) { var information = generator.GetValue(evt.Instance, Concept2.Subject); generator.Push(new InstanceActiveEvent(information, canBeReferenced: true)); yield return($"Yes, I know {singularWithProperty(information)}"); } else if (concept == Concept2.KnowledgeRefutation) { var information = generator.GetValue(evt.Instance, Concept2.Subject); var property = generator.GetValue(evt.Instance, Concept2.Property).Concept; generator.Push(new InstanceActiveEvent(information, canBeReferenced: true)); generator.Push(new IncompleteRelationEvent(information, property, null)); yield return($"No, I don't know {singularWithProperty(information)}"); } else { generator.Push(new InstanceActiveEvent(evt.Instance, canBeReferenced: true)); yield return($"It is {singular(evt.Instance)}"); yield return($"I found {singular(evt.Instance)}"); } }