public void TestRemoveKnowledgeSource_ScheduledSequenceController() { IBlackboard blackboard = new Blackboard(); IScheduledKnowledgeSource ks1 = new KS_ScheduledFilterSelector(blackboard, inputPool: "pool1"); IScheduledKnowledgeSource ks2 = new KS_ScheduledIDSelector(blackboard, inputPool: "pool1", outputPool: "pool2"); IScheduledKnowledgeSource ks3 = new KS_ScheduledUniformDistributionSelector(blackboard, inputPool: "pool2", outputPool: "pool3", numberToSelect: 1); ScheduledSequenceController controller = new ScheduledSequenceController(); controller.AddKnowledgeSource(ks1); controller.AddKnowledgeSource(ks2); controller.AddKnowledgeSource(ks3); Assert.True(controller.RegisteredKnowledgeSource(ks1)); Assert.True(controller.RegisteredKnowledgeSource(ks2)); Assert.True(controller.RegisteredKnowledgeSource(ks3)); controller.RemoveKnowledgeSource(ks3); Assert.True(controller.RegisteredKnowledgeSource(ks1)); Assert.True(controller.RegisteredKnowledgeSource(ks2)); Assert.False(controller.RegisteredKnowledgeSource(ks3)); controller.RemoveKnowledgeSource(ks2); Assert.True(controller.RegisteredKnowledgeSource(ks1)); Assert.False(controller.RegisteredKnowledgeSource(ks2)); Assert.False(controller.RegisteredKnowledgeSource(ks3)); controller.RemoveKnowledgeSource(ks1); Assert.False(controller.RegisteredKnowledgeSource(ks1)); Assert.False(controller.RegisteredKnowledgeSource(ks2)); Assert.False(controller.RegisteredKnowledgeSource(ks3)); }
public Demo3() { Blackboard = new Blackboard(); // _ = ContentUnitSetupForDemos.Demo3_1_DefineUnits(Blackboard, grammarPool); _ = ContentUnitSetupForDemos.Demo3_2_DefineUnits(Blackboard, grammarPool); GenerateTree = new ScheduledSequenceController(); // GenerateTree.AddKnowledgeSource(new KS_KC_ScheduledPrintTree(Blackboard)); var selectTreeLeaves = new KS_ScheduledSelectTreeLeaves(Blackboard, KS_ScheduledContentPoolCollector.GenerateHasComponent <KC_IDSelectionRequest>()); GenerateTree.AddKnowledgeSource(selectTreeLeaves); var highestTierSelector = new KS_ScheduledHighestTierSelector <KC_Order>( Blackboard, inputPool: selectTreeLeaves.OutputPool); GenerateTree.AddKnowledgeSource(highestTierSelector); GenerateTree.AddKnowledgeSource(new KS_ScheduledProcessTreeNode( Blackboard, inputPool: highestTierSelector.OutputPool, processNode: KS_ScheduledProcessTreeNode.ActivateIDRequest)); var idSelector = new KS_ScheduledIDSelector(Blackboard, inputPool: grammarPool); GenerateTree.AddKnowledgeSource(idSelector); var uniformSelector = new KS_ScheduledUniformDistributionSelector( Blackboard, inputPool: idSelector.OutputPool, outputPool: null, numberToSelect: 1); GenerateTree.AddKnowledgeSource(uniformSelector); GenerateTree.AddKnowledgeSource(new KS_ScheduledDefaultGrammarNonterminalDecomposition( Blackboard, inputPool: uniformSelector.OutputPool)); GenerateTree.AddKnowledgeSource(new KS_ScheduledExpandTreeNode( Blackboard, inputPool: uniformSelector.OutputPool)); GenerateTree.AddKnowledgeSource(new KS_ScheduledFilterPoolCleaner( Blackboard, new string[] { selectTreeLeaves.OutputPool, highestTierSelector.OutputPool, idSelector.OutputPool, uniformSelector.OutputPool })); CleanTree = new KS_ScheduledCleanTree(Blackboard); LinearizeTreeLeaves = new KS_ScheduledLinearizeTreeLeaves(Blackboard); }
public Demo2() { Blackboard = new Blackboard(); Demo2_DefineUnits(Blackboard); m_IDSelector = new KS_ScheduledIDSelector(Blackboard); m_prologEval = new KS_ScheduledPrologEval(Blackboard, inputPool: m_IDSelector.OutputPool, prologExpName: ApplTest_Prolog); /* * fixme: consider creating a filtered by boolean result KS or a more general filter by KC_EvaluatedExpression (once I have more EvaluatedExpressions than Prolog). */ m_filterByPrologResult = new KS_ScheduledFilterSelector(Blackboard, inputPool: m_prologEval.OutputPool, outputPool: FilteredPrologResultPool, filter: KS_ScheduledPrologEval.FilterByPrologResult(ApplTest_Prolog, true)); m_uniformRandomSelector = new KS_ScheduledUniformDistributionSelector(Blackboard, inputPool: FilteredPrologResultPool, outputPool: UniformlySelectedOutputPool, numberToSelect: 1); m_choicePresenter = new KS_ScheduledChoicePresenter(Blackboard, UniformlySelectedOutputPool); m_filterPoolCleaner = new KS_ScheduledFilterPoolCleaner(Blackboard, new string[] { m_IDSelector.OutputPool, // Output pool for ID selector m_prologEval.OutputPool, // Output pool for prolog eval m_filterByPrologResult.OutputPool, // Output pool for filter that filters by prolog result m_uniformRandomSelector.OutputPool // Final output pool (written into by UniformDistributionSelector) }); Controller = new ScheduledSequenceController(); Controller.AddKnowledgeSource(m_IDSelector); Controller.AddKnowledgeSource(m_prologEval); Controller.AddKnowledgeSource(m_filterByPrologResult); Controller.AddKnowledgeSource(m_uniformRandomSelector); Controller.AddKnowledgeSource(m_choicePresenter); Controller.AddKnowledgeSource(m_filterPoolCleaner); // Put request for starting content unit in blackboard Unit req = new Unit(); req.AddComponent(new KC_IDSelectionRequest("start", true)); req.SetActiveRequest(true); Blackboard.AddUnit(req); }
public void TestExecute_ScheduledSequenceController() { string id = "id1"; string pool1 = "pool1"; string pool2 = "pool2"; IBlackboard blackboard = new Blackboard(); IScheduledKnowledgeSource ks1 = new KS_ScheduledFilterSelector(blackboard, inputPool: null, outputPool: pool1, filter: (Unit u) => u.HasComponent <KC_UnitID>()); IScheduledKnowledgeSource ks2 = new KS_ScheduledIDSelector(blackboard, inputPool: pool1, outputPool: pool2); ScheduledSequenceController controller = new ScheduledSequenceController(); controller.AddKnowledgeSource(ks1); controller.AddKnowledgeSource(ks2); Unit unit = new Unit(); unit.AddComponent(new KC_UnitID(id)); blackboard.AddUnit(unit); Unit req = new Unit(); req.AddComponent(new KC_IDSelectionRequest(id)); blackboard.AddUnit(req); req.SetActiveRequest(true); controller.Execute(); var pool1Units = from u in blackboard.LookupUnits <Unit>() where u.HasComponent <KC_ContentPool>() where u.ContentPoolEquals(pool1) select u; var pool2Units = from u in blackboard.LookupUnits <Unit>() where u.HasComponent <KC_ContentPool>() where u.ContentPoolEquals(pool2) select u; int pool1Count = pool1Units.Count(); int pool2Count = pool2Units.Count(); Assert.Equal(1, pool1Count); Assert.Equal(1, pool2Count); Assert.True(pool1Units.First().UnitIDEquals(id)); Assert.True(pool2Units.First().UnitIDEquals(id)); }
public Demo1_Scheduled() { Blackboard = new Blackboard(); Demo1_KC_DefineUnits(Blackboard); m_IDSelector = new KS_ScheduledIDSelector(Blackboard); m_uniformRandomSelector = new KS_ScheduledUniformDistributionSelector(Blackboard, inputPool: m_IDSelector.OutputPool, outputPool: null, numberToSelect: 1); m_choicePresenter = new KS_ScheduledChoicePresenter(Blackboard, inputPool: m_uniformRandomSelector.OutputPool); m_filterPoolCleaner = new KS_ScheduledFilterPoolCleaner(Blackboard, new string[] { m_IDSelector.OutputPool, m_uniformRandomSelector.OutputPool }); Controller = new ScheduledSequenceController(); Controller.AddKnowledgeSource(m_IDSelector); Controller.AddKnowledgeSource(m_uniformRandomSelector); Controller.AddKnowledgeSource(m_choicePresenter); Controller.AddKnowledgeSource(m_filterPoolCleaner); // Put request for starting content unit in blackboard Unit req = new Unit(); req.AddComponent(new KC_IDSelectionRequest("start", true)); req.SetActiveRequest(true); Blackboard.AddUnit(req); }
public CFGExpansionController(Unit rootNode, string grammarRulePool, IBlackboard blackboard) { this.blackboard = blackboard; RootNode = rootNode; /* * Replace with three filters: KS_SelectTreeLeaves, which creates a content pool containing all the tree leaves meeting some condition, * KS_ScheduledTierSelector, which, given a component with a sortable value, selects the lowest (in this case it will be order in which a leaf is added to tree), and * KS_ProcessTreeNode, which in this case will activate the ID request and save a reference to the node. KS_ScheduledTierSelector will become abstract, with * several children: KS_ScheduledHighestTierSelector, KS_ScheduledLowestTierSelector, KS_UniformTopNTierSelector, KS_UniformBottomNTierSelector, * KS_ExponentialDistTierSelector. * This decoupling allows other logic to be used in the choice of leaf to expand (such as computing a heuristic for picking a node to expand). */ m_pickLeftmostNodeToExpand = new KS_ScheduledExecute( () => { var nonTerminalLeafNodes = from Unit node in blackboard.LookupUnits <Unit>() where node.HasComponent <KC_TreeNode>() && node.IsTreeLeaf() where node.HasComponent <KC_IDSelectionRequest>() select node; if (nonTerminalLeafNodes.Any()) { nonTerminalLeafNodes.First().SetActiveRequest(true); /* * Save a reference to the current tree node we're expanding on the blackboard. */ Unit leafExpansionRef = new Unit(); leafExpansionRef.AddComponent(new KC_UnitReference(CurrentTreeNodeExpansion, true, nonTerminalLeafNodes.First())); blackboard.AddUnit(leafExpansionRef); } } ); // string idOutputPool = "pool" + DateTime.Now.Ticks; string idOutputPool = "idOutputPool"; m_lookupGrammarRules = new KS_ScheduledIDSelector(blackboard, grammarRulePool, idOutputPool); // string uniformDistOutputPool = "pool" + DateTime.Now.Ticks; string uniformDistOutputPool = "uniformDistOutputPool"; m_chooseGrammarRule = new KS_ScheduledUniformDistributionSelector(blackboard, idOutputPool, uniformDistOutputPool, 1); /* * Replace with KS_ExpandTreeNode. An instance of KS_ExpandTreeNode has: * 1) The name of a content pool a unit with a decomposition. * 2) The name of a KC_UnitReference containing a pointer to the node to expand. */ m_treeExpander = new KS_ScheduledExecute( () => { var rule = from unit in blackboard.LookupUnits <Unit>() where unit.HasComponent <KC_ContentPool>() && unit.ContentPoolEquals(uniformDistOutputPool) select unit; /* * Grab the reference to the current leaf node we're expanding. */ var nodeToExpandQuery = from unit in blackboard.LookupUnits <Unit>() where unit.HasComponent <KC_UnitReference>() select unit; Unit nodeToExpandRef = nodeToExpandQuery.First(); if (rule.Any()) { Debug.Assert(rule.Count() == 1); // Only one rule is picked to expand a symbol Debug.Assert(nodeToExpandQuery.Count() == 1); // Should be only one reference we're expanding. Unit selectedRule = rule.First(); Unit ruleNode = new Unit(selectedRule); // Remove the KC_Decomposition (not needed) and KC_ContentPool (will cause node to be prematurely cleaned up) components ruleNode.RemoveComponent(ruleNode.GetComponent <KC_Decomposition>()); ruleNode.RemoveComponent(ruleNode.GetComponent <KC_ContentPool>()); // fixme: consider defining conversion operators so this looks like // new KC_TreeNode((KC_TreeNode)nodeToExpand); ruleNode.AddComponent(new KC_TreeNode(nodeToExpandRef.GetUnitReference().GetComponent <KC_TreeNode>())); blackboard.AddUnit(ruleNode); // For each of the Units in the decomposition, add them to the tree as children of ruleCopy. foreach (Unit child in selectedRule.GetDecomposition()) { // Make a copy of Unit in the decomposition and add it to the tree. Unit childNode = new Unit(child); blackboard.AddUnit(childNode); childNode.AddComponent(new KC_TreeNode(ruleNode.GetComponent <KC_TreeNode>())); } } else { // No rule was found. Create a pseudo-decomposition consisting of just the TargetUnitID in ## (borrowing from Tracery). Unit noRuleTextDecomp = new Unit(); noRuleTextDecomp.AddComponent(new KC_TreeNode(nodeToExpandRef.GetUnitReference().GetComponent <KC_TreeNode>())); noRuleTextDecomp.AddComponent(new KC_Text("#" + nodeToExpandRef.GetUnitReference().GetTargetUnitID() + "#", true)); blackboard.AddUnit(noRuleTextDecomp); } blackboard.RemoveUnit(nodeToExpandRef); // Remove the reference to the leaf node to expand (it has been expanded). } ); m_cleanSelectionPools = new KS_ScheduledFilterPoolCleaner(blackboard, new string[] { idOutputPool, uniformDistOutputPool }); bool GenSequencePrecond() { var leafNodes = from Unit node in blackboard.LookupUnits <Unit>() where node.HasComponent <KC_TreeNode>() && node.IsTreeLeaf() select node; // This is ready to run if no leaf node contains a KC_IDSelectionRequest component (meaning it's a non-terminal). return(leafNodes.All(node => !node.HasComponent <KC_IDSelectionRequest>())); } /* * Replace with KS_LinearizeTreeLeaves. */ void GenSequenceExec() { // Walk the tree to find the leafs from left to right. IList <Unit> leafs = new List <Unit>(); AddLeafs(RootNode, leafs); // Write out the leafs of the generated tree foreach (Unit leaf in leafs) { Console.Write(leaf.GetText() + " "); } // Delete the tree. var treeNodes = from Unit node in blackboard.LookupUnits <Unit>() where node.HasComponent <KC_TreeNode>() select node; foreach (var node in treeNodes) { blackboard.RemoveUnit(node); } } m_addGeneratedSequence = new KS_ScheduledExecute(GenSequenceExec, GenSequencePrecond); }