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);
}
