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 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 activations = generator.GetInstanceActivations();
foreach (var relevantInstanceActivation in activations)
{
if (!relevantInstanceActivation.CanBeReferenced)
{
continue;
}
var relevantInstance = relevantInstanceActivation.Instance;
if (relevantInstance == instance)
{
//dont reference self
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 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));
}
public static void BeamBranchTesting()
{
var b = new BeamGenerator();
b.Push(new InputPhraseEvent("x"));
b.Pop();
b.Push(new InputPhraseEvent("y"));
b.PushSelf();
}
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 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 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 IEnumerable <string> execute(BeamGenerator generator)
{
var activeInstance = Get <InstanceActiveEvent>(e => e.Request != null && e.Request.ActivationPhrases.Any() && canBeReported(e.Instance));
if (activeInstance == null)
{
yield break;
}
generator.Push(new Events.StaticScoreEvent(-0.3));
generator.Push(new InstanceReferencedEvent(activeInstance.Instance));
yield return($"I know {singular(activeInstance.Instance)} but what should I do?");
}
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 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));
}
}
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)
{
generator.Push(new Events.StaticScoreEvent(-0.5));
yield return("How can I help you?");
yield return("I need to know what should I do.");
yield return("Please, tell me what should I do.");
}
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 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) + " ?");
}
}
internal static void GenerateActivationRequest(string unknown, BeamGenerator generator)
{
var newConcept = Concept2.From(unknown);
var newConceptInstance = new ConceptInstance(newConcept);
var learnInstance = new ConceptInstance(Concept2.LearnNewConcept);
generator.SetValue(learnInstance, Concept2.Unknown, newConceptInstance);
generator.Push(new InstanceActivationRequestEvent(learnInstance));
}
private void pushNewOptions(IEnumerable <ConceptInstance> options, BeamGenerator generator)
{
var optionPrompt = new ConceptInstance(Concept2.OptionPrompt);
foreach (var option in options)
{
generator.SetValue(optionPrompt, Concept2.Option, option);
}
generator.Push(new InstanceActivationRequestEvent(optionPrompt));
}
private void pushNewDisambiguation(IEnumerable <ConceptInstance> indirectSubjects, ConceptInstance unknown, ConceptInstance target, BeamGenerator generator)
{
var disambiguation = new ConceptInstance(Concept2.PropertyValueDisambiguation);
generator.SetValue(disambiguation, Concept2.Unknown, unknown);
generator.SetValue(disambiguation, Concept2.Target, target);
foreach (var subject in indirectSubjects)
{
generator.SetValue(disambiguation, Concept2.Subject, subject);
}
generator.Push(new InstanceActivationRequestEvent(disambiguation));
}
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);
}
}
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 IEnumerable <string> execute(BeamGenerator generator)
{
var evt = Get <PropertySetEvent>(p => p.Target.Property == Concept2.HasProperty);
if (evt == null)
{
yield break;
}
var learnedProperty = evt.SubstitutedValue;
var propertyTarget = evt.Target.Instance;
var request = new IncompleteRelationEvent(propertyTarget, learnedProperty.Concept, null);
generator.Push(request);
yield return($"What value of '{singular(learnedProperty)}' does {singular(propertyTarget)} have ?");
}
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 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 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?");
}
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 ?");
}
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var unknownPhrases = GetUnknownPhrases(generator).ToArray();
if (unknownPhrases.Length != 1)
{
yield break;
}
var phraseToAsk = unknownPhrases.First();
if (phraseToAsk.Split(' ').Length > 2)
{
yield break;
}
var newConcept = Concept2.From(phraseToAsk);
var newConceptInstance = new ConceptInstance(newConcept);
var handlePropertyInstance = new ConceptInstance(Concept2.AcceptNewProperty);
generator.SetValue(handlePropertyInstance, Concept2.Property, newConceptInstance);
var handleConceptInstance = new ConceptInstance(Concept2.Nothing);
var options = new Dictionary <Concept2, ConceptInstance>()
{
{ Concept2.Property, handlePropertyInstance },
{ Concept2.ConceptName, handleConceptInstance },
};
var prompt = OptionPrompt.CreatePrompt(options, generator);
//remember runtime info so others can use it
generator.SetValue(TagInstance, Concept2.Unknown, newConceptInstance);
generator.SetValue(TagInstance, Concept2.Prompt, prompt);
generator.Push(new InstanceActivationRequestEvent(prompt));
yield return($"What does '{unknownPhrases.First()}' mean?");
}
protected override IEnumerable <string> execute(BeamGenerator generator)
{
var fullRelation = Get <PropertySetEvent>(p => IsDefined(p.SubstitutedValue.Concept) && IsDefined(p.Target.Instance?.Concept));
if (fullRelation == null)
{
yield break;
}
var targetInstance = fullRelation.Target.Instance;
if (targetInstance == null)
{
yield break;
}
var children = generator.GetInverseConceptValues(Concept2.InstanceOf, targetInstance);
if (children.Any())
{
//TODO add learning for classes
yield break;
}
var parameters = generator.GetParameterDefinitions(targetInstance);
if (parameters.Any(p => p.Property == fullRelation.Target.Property))
{
//don't learn argument values
yield break;
}
generator.Push(new StaticScoreEvent(0.1));
var remember = RememberPropertyValue.Create(generator, fullRelation.Target, fullRelation.SubstitutedValue);
YesNoPrompt.Generate(generator, remember, new ConceptInstance(Concept2.Nothing));
yield return($"So you think, {singularWithProperty(fullRelation.Target.Instance)} ?");
}
