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 IEnumerable <string> GetUnknownPhrases(BeamGenerator generator)
{
var allInputPhrases = GetMany <InputPhraseEvent>();
var currentBuffer = new List <InputPhraseEvent>();
foreach (var inputPhrase in allInputPhrases)
{
var phrase = inputPhrase;
var isPhraseDisconnected = currentBuffer.Count > 0 && phrase.InputId - currentBuffer.Last().InputId != 1;
if (generator.IsInputUsed(phrase) || isDelimiter(inputPhrase) || isPhraseDisconnected)
{
if (currentBuffer.Count > 0)
{
yield return(composeUnknownPhrase(currentBuffer));
}
currentBuffer.Clear();
continue;
}
currentBuffer.Add(phrase);
}
if (currentBuffer.Count > 0)
{
yield return(composeUnknownPhrase(currentBuffer));
}
}
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 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();
}
}
internal override IEnumerable <string> GenerateFeatures(BeamNode node)
{
var targetActivationEvent = BeamGenerator.GetInstanceActivationRequest(PropertySet.Subject, node);
var sourceActivationEvent = BeamGenerator.GetInstanceActivationRequest(PropertySet.Value, node);
if (targetActivationEvent == null || sourceActivationEvent == null)
{
yield break;
}
var ngramLimitCount = 2;
var targetSufixes = new InputPhraseEvent[0];//BeamGenerator.GetSufixPhrases(targetActivationEvent.ActivationPhrase, ngramLimitCount, node);
var targetPrefixes = BeamGenerator.GetPrefixPhrases(targetActivationEvent.ActivationPhrases.FirstOrDefault(), ngramLimitCount, node);
var featureId = "* --" + PropertySet.Property.Name + "--> $1";
var targetId = "$1";
for (var i = 0; i < ngramLimitCount; ++i)
{
if (targetSufixes.Length > i)
{
yield return(targetId + " " + ngramFeature(targetSufixes, i) + " | " + featureId);
}
if (targetPrefixes.Length > i)
{
yield return(ngramFeature(targetPrefixes, i) + " " + targetId + " | " + featureId);
}
}
}
internal static List <ConceptInstance> FindRelevantConcepts(BeamGenerator generator, HashSet <Concept2> requiredProperties)
{
//TODO better matching logic
var concepts = generator.GetDefinedConcepts();
var result = new List <ConceptInstance>();
foreach (var concept in concepts)
{
var conceptInstance = new ConceptInstance(concept);
var missingProperties = new HashSet <Concept2>(requiredProperties);
foreach (var propertyValue in generator.GetPropertyValues(conceptInstance))
{
var property = propertyValue.Key;
var value = propertyValue.Value;
missingProperties.Remove(value.Concept);
}
if (missingProperties.Count == 0)
{
result.Add(conceptInstance);
}
}
return(result);
}
private void ConnectToBeamGenerator()
{
try
{
// connect with bbeam gnerators
beamGenerators = part.FindModulesImplementing <BeamGenerator>().Where(m => (m.beamType & compatibleBeamTypes) == m.beamType).ToList();
if (beamGenerators.Count == 0 && part.parent != null)
{
beamGenerators.AddRange(part.parent.FindModulesImplementing <BeamGenerator>().Where(m => (m.beamType & compatibleBeamTypes) == m.beamType));
}
if (beamGenerators.Count == 0)
{
var attachedParts = part.attachNodes
.Where(m => m.attachedPart != null)
.Select(m => m.attachedPart)
.SelectMany(m => m.FindModulesImplementing <BeamGenerator>())
.Where(m => (m.beamType & compatibleBeamTypes) == m.beamType);
beamGenerators.AddRange(attachedParts);
}
activeBeamGenerator = beamGenerators.FirstOrDefault();
if (activeBeamGenerator != null && activeBeamGenerator.part != this.part)
{
activeBeamGenerator.UpdateMass(this.maximumPower);
}
}
catch (Exception ex)
{
Debug.LogError("[KSPI] Microwave Transmitter OnStart search for beamGenerator: " + ex);
}
}
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();
}
}
GameObject SpawnObject(GameObject prev)
{
GameObject myChildObject, clone;
if (prev.transform.childCount > 0)
{
myChildObject = prev.transform.GetChild(0).gameObject;
prev.transform.DetachChildren();
clone = Instantiate(prev, transform.position, transform.rotation);
myChildObject.transform.parent = prev.transform;
}
else
{
clone = Instantiate(prev, transform.position, transform.rotation);
}
GameObject storey = new GameObject();
storey.transform.SetParent(transform);
clone.transform.SetParent(storey.transform);
RandomScaleObject(clone);
clone.GetComponent <MeshRenderer>().material = material;
BeamGenerator beamGen = clone.GetComponent <BeamGenerator>();
beamGen.seed = Random.Range(0, 100000);
beamGen.Generate();
return(clone);
}
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?");
}
public override string GenerateSharedPixelShader(ShaderStage stage, int methodIndex, int optionIndex)
{
var gen = new BeamGenerator();
var bytecode = gen.GenerateSharedPixelShader(stage, methodIndex, optionIndex).Bytecode;
return(D3DCompiler.Disassemble(bytecode));
}
public override string GenerateSharedVertexShader(VertexType vertex, ShaderStage stage)
{
var gen = new BeamGenerator();
var bytecode = gen.GenerateSharedVertexShader(vertex, stage).Bytecode;
return(D3DCompiler.Disassemble(bytecode));
}
internal static ConceptInstance Create(BeamGenerator generator, Concept2 subject, string description)
{
var instance = new ConceptInstance(Concept2.RememberConceptDescription);
generator.SetValue(instance, Concept2.Subject, new ConceptInstance(subject));
generator.SetValue(instance, Concept2.Description, new ConceptInstance(Concept2.From(description)));
return(instance);
}
internal override double GetDefaultScore(BeamNode node)
{
var descriptions = BeamGenerator.GetDescriptions(Concept, node);
var composedPhrase = getComposedPhrase();
return(getSimilarity(composedPhrase, Concept.Name, descriptions)); //TODO solve the descriptions
}
internal static ConceptInstance Create(BeamGenerator generator, ConceptInstance yesInstance, ConceptInstance noInstance)
{
var prompt = new ConceptInstance(Concept2.Prompt);
generator.SetValue(prompt, Concept2.Yes, yesInstance);
generator.SetValue(prompt, Concept2.No, noInstance);
return(prompt);
}
public static void BeamBranchTesting()
{
var b = new BeamGenerator();
b.Push(new InputPhraseEvent("x"));
b.Pop();
b.Push(new InputPhraseEvent("y"));
b.PushSelf();
}
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 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));
}
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));
}
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));
}
internal static ConceptInstance Create(BeamGenerator generator, PropertySetTarget target, ConceptInstance value)
{
var rememberValue = new ConceptInstance(Concept2.RememberPropertyValue);
generator.SetValue(rememberValue, Concept2.Target, target.Instance);
generator.SetValue(rememberValue, Concept2.TargetProperty, new ConceptInstance(target.Property));
generator.SetValue(rememberValue, Concept2.Subject, value);
return(rememberValue);
}
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));
}
public override string GeneratePixelShader(ShaderStage stage, List <int> shaderOptions)
{
var albedo = (Albedo)shaderOptions[0];
var blend_mode = (Blend_Mode)shaderOptions[1];
var black_point = (Black_Point)shaderOptions[2];
var fog = (Fog)shaderOptions[3];
var gen = new BeamGenerator(albedo, blend_mode, black_point, fog);
var bytecode = gen.GeneratePixelShader(stage).Bytecode;
return(D3DCompiler.Disassemble(bytecode));
}
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?");
}
internal static void States(BeamGenerator generator, int stateCount = int.MaxValue)
{
var rankedNodes = generator.GetRankedNodes().ToArray();
var rankedStates = rankedNodes.Take(stateCount).Reverse().ToArray();
foreach (var state in rankedStates)
{
Indent();
State(state.Value);
Dedent();
Writeln($"S: {state.Rank:0.00} | N: {rankedNodes.Length} > ", HeadlineColor);
Writeln("\n", HeadlineColor);
}
}
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 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 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));
}
}
