/// <summary>
/// Setup the ACS subsystem
/// </summary>
private void SetupACS()
{
// Create Rule to rotate
SupportCalculator rotateSupportCalculator = FixedRuleToRotate;
FixedRule ruleRotate = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputRotateClockwise, rotateSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleRotate);
// Create Colission To Go Ahead
SupportCalculator goAheadSupportCalculator = FixedRuleToGoAhead;
FixedRule ruleGoAhead = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoAhead, goAheadSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoAhead);
// Create Colission To Eat
SupportCalculator eatSupportCalculator = FixedRuleToEat;
FixedRule ruleEat = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputEat, eatSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleEat);
// Create Colission To Sack
SupportCalculator sackSupportCalculator = FixedRuleToSack;
FixedRule ruleSack = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputSack, sackSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleSack);
// Create Colission To Hide
SupportCalculator hideSupportCalculator = FixedRuleToHide;
FixedRule ruleHide = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputHide, hideSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleHide);
// Create Colission To Stop
SupportCalculator stopSupportCalculator = FixedRuleToStop;
FixedRule ruleStop = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputStop, stopSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleStop);
// Disable Rule Refinement
CurrentAgent.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
// The selection type will be probabilistic
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.STOCHASTIC;
// The action selection will be fixed (not variable) i.e. only the statement defined above.
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
// Define Probabilistic values
CurrentAgent.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 1;
CurrentAgent.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 0;
}
/// <summary>
/// Setup the ACS subsystem
/// </summary>
private void SetupACS()
{
// Create Rule to avoid collision with wall
SupportCalculator avoidCollisionWallSupportCalculator = FixedRuleToAvoidCollisionWall;
FixedRule ruleAvoidCollisionWall = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputRotateClockwise, avoidCollisionWallSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleAvoidCollisionWall);
// Create Rule to avoid collision with wall
SupportCalculator goItemSupportCalculator = FixedRuleToGoItem;
FixedRule ruleGoItem = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoItem, goItemSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoItem);
// Create Rule to avoid collision with wall
SupportCalculator sackItItemSupportCalculator = FixedRuleToSackItItem;
FixedRule ruleSackItItem = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputSackItItem, sackItItemSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleSackItItem);
// Create Rule to avoid collision with wall
SupportCalculator eatItemSupportCalculator = FixedRuleToEatItem;
FixedRule ruleEatItem = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputEatItem, eatItemSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleEatItem);
// Create Rule to avoid collision with wall
SupportCalculator stopCreatureSupportCalculator = FixedRuleToStopCreature;
FixedRule ruleStopCreature = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputStopCreature, stopCreatureSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleStopCreature);
// Disable Rule Refinement
CurrentAgent.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
// The selection type will be probabilistic
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.STOCHASTIC;
// The action selection will be fixed (not variable) i.e. only the statement defined above.
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
// Define Probabilistic values
CurrentAgent.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 1;
CurrentAgent.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 0;
}
public void TryGetTollFee_Handle_Specified_Vehicles()
{
var expectedTollFee = 10;
var vehicle = new Mock <IVehicle>();
var rule = new FixedRule(expectedTollFee, new[] { vehicle.Object });
var actualTollFee = rule.GetTollFee(vehicle.Object, new DateTime(2018, 12, 22, 0, 30, 0));
Assert.Equal(expectedTollFee, actualTollFee, 0);
}
public void TryGetTollFee_Returns_Specified_Toll_Fee()
{
var expectedTollFee = 10;
var vehicle = new Mock <IVehicle>();
var rule = new FixedRule(expectedTollFee, null);
var actualTollFee = rule.GetTollFee(vehicle.Object, new DateTime(2018, 12, 22, 0, 30, 0));
Assert.Equal(expectedTollFee, actualTollFee, 0);
}
public void TryGetTollFee_Do_Not_Handle_Unspecified_Vehicles()
{
var expectedTollFee = 0;
var handledVehicle = new Mock <IVehicle>();
var checkedVehicle = new Mock <IVehicle>();
var rule = new FixedRule(10, new[] { handledVehicle.Object });
var actualTollFee = rule.GetTollFee(checkedVehicle.Object, new DateTime(2018, 12, 22, 0, 30, 0));
Assert.Equal(expectedTollFee, actualTollFee, 0);
}
public void IsSatisfied()
{
_fixedRule = new FixedRule();
Assert.IsFalse(_fixedRule.IsSatisfied(0));
Assert.IsFalse(_fixedRule.IsSatisfied(1));
Assert.IsFalse(_fixedRule.IsSatisfied(2));
Assert.IsFalse(_fixedRule.IsSatisfied(9));
_fixedRule = new FixedRule(1, 2, 3);
Assert.IsFalse(_fixedRule.IsSatisfied(0));
Assert.IsTrue(_fixedRule.IsSatisfied(1));
Assert.IsTrue(_fixedRule.IsSatisfied(2));
Assert.IsTrue(_fixedRule.IsSatisfied(3));
Assert.IsFalse(_fixedRule.IsSatisfied(4));
Assert.IsFalse(_fixedRule.IsSatisfied(5));
Assert.IsFalse(_fixedRule.IsSatisfied(6));
Assert.IsFalse(_fixedRule.IsSatisfied(7));
Assert.IsFalse(_fixedRule.IsSatisfied(8));
Assert.IsFalse(_fixedRule.IsSatisfied(9));
Assert.IsFalse(_fixedRule.IsSatisfied(10));
}
/// <summary>
/// Setup the ACS subsystem
/// </summary>
private void SetupACS()
{
// Create Rule to avoid collision with wall
SupportCalculator avoidCollisionWallSupportCalculator = FixedRuleToAvoidCollisionWall;
FixedRule ruleAvoidCollisionWall = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputRotateClockwise, avoidCollisionWallSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleAvoidCollisionWall);
// Create Colission To Go Ahead
SupportCalculator goAheadSupportCalculator = FixedRuleToGoAhead;
FixedRule ruleGoAhead = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoAhead, goAheadSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoAhead);
// Create Go to Jewel
SupportCalculator goToJewelSupportCalculator = FixedRuleToGoToJewel;
FixedRule ruleGoToJewel = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoToJewelInVision, goToJewelSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoToJewel);
// Create eat food
SupportCalculator eatFoodSupportCalculator = FixedRuleToEatFood;
FixedRule ruleEatFood = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputEatFood, eatFoodSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleEatFood);
// Create get desired jewel
SupportCalculator getDesiredJewelSupportCalculator = FixedRuleToGetDesiredJewel;
FixedRule ruleGetDesiredJewel = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGetJewel, getDesiredJewelSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGetDesiredJewel);
// Create hide jewel
SupportCalculator hideJewelSupportCalculator = FixedRuleToHideJewel;
FixedRule ruleHideJewel = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputHideJewel, hideJewelSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleHideJewel);
// Create goal achieved
SupportCalculator goalAchievedSupportCalculator = FixedRuleGoalAchieved;
FixedRule ruleGoalAchieved = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoalAchieved, goalAchievedSupportCalculator);
// Create fuel low rule
SupportCalculator fuelLowSupportCalculator = FixedRuleFuelLow;
FixedRule ruleFuelLow = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputFuelLow, fuelLowSupportCalculator);
CurrentAgent.Commit(ruleFuelLow);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoalAchieved);
// Disable Rule Refinement
CurrentAgent.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
// The selection type will be probabilistic
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.STOCHASTIC;
// The action selection will be fixed (not variable) i.e. only the statement defined above.
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
// Define Probabilistic values
CurrentAgent.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 1;
CurrentAgent.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 0;
}
/// <summary>
/// Setup the ACS subsystem
/// </summary>
private void SetupACS()
{
// Create Rule To Stop when all leaflets have been delivered (success)
SupportCalculator stopWhenFinishedSupportCalculator = FixedRuleToStopWhenFinished;
FixedRule ruleStopWhenFinished = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputStop, stopWhenFinishedSupportCalculator);
ruleStopWhenFinished.Parameters.WEIGHT = 1;
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleStopWhenFinished);
// Create Rule to Eat Food
SupportCalculator eatFoodSupportCalculator = FixedRuleToEatFood;
FixedRule ruleEatFood = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputEatFood, eatFoodSupportCalculator);
ruleEatFood.Parameters.WEIGHT = 0.9;
ruleEatFood.Parameters.PARTIAL_MATCH_ON = true;
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleEatFood);
// Create Rule to Collect (Sack) Jewel
SupportCalculator sackJewelSupportCalculator = FixedRuleToSackJewel;
FixedRule ruleSackJewel = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputSackJewel, sackJewelSupportCalculator);
ruleSackJewel.Parameters.WEIGHT = 0.9;
ruleSackJewel.Parameters.PARTIAL_MATCH_ON = true;
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleSackJewel);
// Create Rule to avoid colision with wall
SupportCalculator avoidCollisionWallSupportCalculator = FixedRuleToAvoidCollisionWall;
FixedRule ruleAvoidCollisionWall = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputRotateClockwise, avoidCollisionWallSupportCalculator);
ruleAvoidCollisionWall.Parameters.WEIGHT = 0.8;
ruleAvoidCollisionWall.Parameters.PARTIAL_MATCH_ON = true;
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleAvoidCollisionWall);
// Create Rule To Go Ahead
//SupportCalculator goAheadSupportCalculator = FixedRuleToGoAhead;
//FixedRule ruleGoAhead = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoAhead, goAheadSupportCalculator);
// Commit this rule to Agent (in the ACS)
//CurrentAgent.Commit(ruleGoAhead);
// Create Rule To Go To Closest Jewel
SupportCalculator goToClosestJewelSupportCalculator = FixedRuleToGoToClosestJewel;
FixedRule ruleGoToClosestJewel = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoToClosestJewel, goToClosestJewelSupportCalculator);
ruleGoToClosestJewel.Parameters.WEIGHT = 0.7;
ruleGoToClosestJewel.Parameters.PARTIAL_MATCH_ON = true;
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoToClosestJewel);
// Create Rule To Go To Closest Jewel
SupportCalculator goToClosestFoodSupportCalculator = FixedRuleToGoToClosestFood;
FixedRule ruleGoToClosestFood = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoToClosestFood, goToClosestFoodSupportCalculator);
ruleGoToClosestFood.Parameters.WEIGHT = 0.6;
ruleGoToClosestFood.Parameters.PARTIAL_MATCH_ON = true;
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoToClosestFood);
// Create Rule to Deliver a Leaflet
SupportCalculator deliverLeafletSupportCalculator = FixedRuleToDeliverLeaflet;
FixedRule ruleDeliverLeaflet = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputDeliverLeaflet, deliverLeafletSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleDeliverLeaflet);
// Disable Rule Refinement
CurrentAgent.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
// The selection type will be probabilistic
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.STOCHASTIC;
// The action selection will be fixed (not variable) i.e. only the statement defined above.
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
// Define Probabilistic values
CurrentAgent.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 1;
CurrentAgent.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 0;
}
public void Initialize()
{
// Dimension Value Pairs:
sayWhat = World.NewDimensionValuePair("YourAction", "What do you want to do?");
// External Action Chunks:
sayCooperate = World.NewExternalActionChunk("Cooperate");
sayDefect = World.NewExternalActionChunk("Defect");
// placeholder
// GoalChunk salute = World.NewGoalChunk("Salute");
// GoalChunk bidFarewell = World.NewGoalChunk("Bid Farewell");
// WM Actions:
wmuacC = World.NewWorkingMemoryUpdateActionChunk("Remember my opponent cooperated");
wmuacD = World.NewWorkingMemoryUpdateActionChunk("Remember my opponent defected");
DeclarativeChunk dcoc = World.NewDeclarativeChunk("My opponent cooperated");
DeclarativeChunk dcod = World.NewDeclarativeChunk("My opponent defected");
wmuacC.Add(WorkingMemory.RecognizedActions.SET_RESET, dcoc);
wmuacD.Add(WorkingMemory.RecognizedActions.SET_RESET, dcod);
// Set up a two agent model (meaning two agents with the same setup, playing against each other)
Alice = World.NewAgent("Alice");
Bob = World.NewAgent("Bob");
// Simulating environment will determine inputs to each agent based on what each agent does..
// Feedback is determined by payoff matrix..
payoff = new int [2, 2, 2];
// Doing this the hard way. Could set this up all in-line above, but this makes the table
// more explicit in terms of how we want to use it.
// The payoff matrix here is called "Friend or Foe", about the simplest case
// indices mean: FOR-WHICH-AGENT, WHAT-ALICE-DOES, WHAT-BOB-DOES
payoff[_ALICE, _COOPERATE, _COOPERATE] = 1;
payoff[_ALICE, _COOPERATE, _DEFECT] = 0;
payoff[_ALICE, _DEFECT, _COOPERATE] = 2;
payoff[_ALICE, _DEFECT, _DEFECT] = 0;
payoff[_BOB, _COOPERATE, _COOPERATE] = 1;
payoff[_BOB, _COOPERATE, _DEFECT] = 2;
payoff[_BOB, _DEFECT, _COOPERATE] = 0;
payoff[_BOB, _DEFECT, _DEFECT] = 0;
maxpay = 2;
results = new int[_TRIALS, 2, 2];
// Set up a Q-learning Net =
// -- Eligibility Condition = True if "What do you want to do?" is in input, otherwise False
// -- Input = "My opponent cooperated", "My opponent defected", "What do you want to do?"
// -- Output = "I want to defect", "I want to cooperate"
//
// Also, RER is turned ON
QBPNetwork net_A = AgentInitializer.InitializeImplicitDecisionNetwork(Alice, QBPNetwork.Factory, QNetEC);
net_A.Input.Add(sayWhat);
net_A.Input.Add(sayCooperate);
net_A.Input.Add(sayDefect);
net_A.Output.Add(sayCooperate);
net_A.Output.Add(sayDefect);
Alice.Commit(net_A);
net_A.Parameters.LEARNING_RATE = 1;
Alice.ACS.Parameters.PERFORM_RER_REFINEMENT = true; // it's true by default anyway
Alice.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.COMBINED;
Alice.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
Alice.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 1;
Alice.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 1;
Alice.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 1;
Alice.ACS.Parameters.WM_UPDATE_ACTION_PROBABILITY = 1;
// Rules (2 rules) =
// Rule 1:
// -- Condition = "Your opponent cooperated"
// -- Action = Set "My opponent cooperated" in WM
// Rule 2:
// -- Condition = "Your opponent defected"
// -- Action = Set "My opponent defect" in WM
FixedRule ruleA1 = AgentInitializer.InitializeActionRule(Alice, FixedRule.Factory, wmuacC, FRSC);
FixedRule ruleA2 = AgentInitializer.InitializeActionRule(Alice, FixedRule.Factory, wmuacD, FRSC);
Alice.Commit(ruleA1);
Alice.Commit(ruleA2);
QBPNetwork net_B = AgentInitializer.InitializeImplicitDecisionNetwork(Bob, QBPNetwork.Factory, QNetEC);
net_B.Input.Add(sayWhat);
net_B.Input.Add(sayCooperate);
net_B.Input.Add(sayDefect);
net_B.Output.Add(sayCooperate);
net_B.Output.Add(sayDefect);
Bob.Commit(net_B);
// Use Weighted Combination
// NO partial match on TL
net_B.Parameters.LEARNING_RATE = 1;
Bob.ACS.Parameters.PERFORM_RER_REFINEMENT = true;
Bob.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.COMBINED;
Bob.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
Bob.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 1;
Bob.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 1;
Bob.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 1;
Bob.ACS.Parameters.WM_UPDATE_ACTION_PROBABILITY = 1;
FixedRule ruleB1 = AgentInitializer.InitializeActionRule(Bob, FixedRule.Factory, wmuacC, FRSC);
FixedRule ruleB2 = AgentInitializer.InitializeActionRule(Bob, FixedRule.Factory, wmuacD, FRSC);
Bob.Commit(ruleB1);
Bob.Commit(ruleB2);
// Initially using the same parameters for RER as Full Hello World
RefineableActionRule.GlobalParameters.SPECIALIZATION_THRESHOLD_1 = -.6;
RefineableActionRule.GlobalParameters.GENERALIZATION_THRESHOLD_1 = -.1;
RefineableActionRule.GlobalParameters.INFORMATION_GAIN_OPTION = RefineableActionRule.IGOptions.PERFECT;
/*
* Note -- What should be seems is that when you pass in "Your opponent…",
* the agent should return the "Do Nothing" external action
* (since it performed an internal WM action)..
* However, you can just ignore this either way..
*/
}
/// <summary>
/// Setup the ACS subsystem
/// </summary>
private void SetupACS()
{
// Create Rule to avoid collision with wall
SupportCalculator avoidCollisionWallSupportCalculator = FixedRuleToAvoidCollisionWall;
FixedRule ruleAvoidCollisionWall = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputRotateClockwise, avoidCollisionWallSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleAvoidCollisionWall);
// Create Rule To Go Ahead
SupportCalculator goAheadSupportCalculator = FixedRuleToGoAhead;
FixedRule ruleGoAhead = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoAhead, goAheadSupportCalculator);
// Commit this rule to Agent (in the ACS) - FMT commenting to avoid conflict
//CurrentAgent.Commit(ruleGoAhead);
// FMT 29/04/2017
// FMT Create Rule to Eat
SupportCalculator eatSupportCalculator = FixedRuleToEat;
FixedRule ruleEat = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputEat, eatSupportCalculator);
CurrentAgent.ACS.Parameters.PERFORM_RER_REFINEMENT = true;
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.COMBINED;
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
CurrentAgent.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 1;
CurrentAgent.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 1;
CurrentAgent.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 1;
CurrentAgent.ACS.Parameters.WM_UPDATE_ACTION_PROBABILITY = 1;
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleEat);
// FMT Create Rule to Get
SupportCalculator getSupportCalculator = FixedRuleToGet;
FixedRule ruleGet = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGet, getSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGet);
// FMT Create Rule to Hide
SupportCalculator hideSupportCalculator = FixedRuleToHide;
FixedRule ruleHide = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputHide, hideSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleHide);
// FMT Create Rule to Go To
SupportCalculator gotoSupportCalculator = FixedRuleToGoTo;
FixedRule ruleGoto = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoTo, gotoSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoto);
// FMT Create Rule to Stop
SupportCalculator stopSupportCalculator = FixedRuleToStop;
FixedRule ruleStop = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputStop, stopSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleStop);
// Disable Rule Refinement
CurrentAgent.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
// The selection type will be probabilistic
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.STOCHASTIC;
// The action selection will be fixed (not variable) i.e. only the statement defined above.
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
// Define Probabilistic values
CurrentAgent.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 1;
CurrentAgent.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 0;
// FMT 13/05/2017 additonal setting for network
SimplifiedQBPNetwork net = AgentInitializer.InitializeImplicitDecisionNetwork(CurrentAgent, SimplifiedQBPNetwork.Factory);
net.Parameters.LEARNING_RATE = 1;
CurrentAgent.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
}
/// <summary>
/// Setup the ACS subsystem
/// </summary>
private void SetupACS()
{
// Create Rule to avoid collision with wall
SupportCalculator avoidCollisionWallSupportCalculator = FixedRuleToAvoidCollisionWall;
FixedRule ruleAvoidCollisionWall = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputRotateClockwise, avoidCollisionWallSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleAvoidCollisionWall);
// Create Rule to Wander
SupportCalculator wanderSupportCalculator = FixedRuleToWander;
FixedRule ruleWander = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputWander, wanderSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleWander);
// Create Rule To Get Jewel
SupportCalculator getJewelSupportCalculator = FixedRuleToGetJewel;
FixedRule ruleGetJewel = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGetJewel, getJewelSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGetJewel);
// Create Rule To Get Food
SupportCalculator getFoodSupportCalculator = FixedRuleToGetFood;
FixedRule ruleGetFood = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGetFood, getFoodSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGetFood);
// Create Rule To Go To Jewel
SupportCalculator goToJewelSupportCalculator = FixedRuleToGoToJewel;
FixedRule ruleGoToJewel = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoToJewel, goToJewelSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoToJewel);
// Create Rule To Go To Food
SupportCalculator goToFoodSupportCalculator = FixedRuleToGoToFood;
FixedRule ruleGoToFood = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoToFood, goToFoodSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoToFood);
// Create Rule To Go To the Delivery Spot
SupportCalculator goToDeliverySpotSupportCalculator = FixedRuleToGoToDeliverySpot;
FixedRule ruleGoToDeliverySpot = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputGoToDeliverySpot,
goToDeliverySpotSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleGoToDeliverySpot);
// Create Rule To Deliver Jewels
SupportCalculator deliverSupportCalculator = FixedRuleToDeliver;
FixedRule ruleDeliver = AgentInitializer.InitializeActionRule(CurrentAgent, FixedRule.Factory, outputDoDelivery,
deliverSupportCalculator);
// Commit this rule to Agent (in the ACS)
CurrentAgent.Commit(ruleDeliver);
// Disable Rule Refinement
CurrentAgent.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
// The selection type will be probabilistic
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.STOCHASTIC;
// The action selection will be fixed (not variable) i.e. only the statement defined above.
CurrentAgent.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
// Define Probabilistic values
CurrentAgent.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 1;
CurrentAgent.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 0;
CurrentAgent.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 0;
}
public void Initialize(Groups group)
{
World.Initialize();
John = World.NewAgent();
QBPNetwork idn = AgentInitializer.InitializeImplicitDecisionNetwork(John, QBPNetwork.Factory);
World.NewDimensionValuePair("Target P", target);
World.NewDimensionValuePair("Current P", target);
World.NewExternalActionChunk(target);
for (double i = 0; i < 12; i++)
{
if (World.GetDimensionValuePair("Target P", i) == null)
{
idn.Input.Add(World.NewDimensionValuePair("Target P", i));
idn.Input.Add(World.NewDimensionValuePair("Current P", i));
idn.Input.Add(World.NewExternalActionChunk(i));
idn.Output.Add(World.GetActionChunk(i));
}
else
{
idn.Input.Add(World.GetDimensionValuePair("Target P", i));
idn.Input.Add(World.GetDimensionValuePair("Current P", i));
idn.Input.Add(World.GetActionChunk(i));
idn.Output.Add(World.GetActionChunk(i));
}
}
foreach (double i in As)
{
World.NewDimensionValuePair("A", i);
}
foreach (double i in Bs)
{
World.NewDimensionValuePair("B", i);
}
foreach (double i in Cs)
{
World.NewDimensionValuePair("C", i);
}
switch (group)
{
case Groups.VERBALIZATION:
idn.Parameters.POSITIVE_MATCH_THRESHOLD = 1;
RefineableActionRule.GlobalParameters.POSITIVE_MATCH_THRESHOLD = 1;
RefineableActionRule.GlobalParameters.GENERALIZATION_THRESHOLD_1 = 1;
RefineableActionRule.GlobalParameters.SPECIALIZATION_THRESHOLD_1 = .5;
threshold_4 = .5;
break;
case Groups.MEMORY:
for (double i = 0; i < 12; i++)
{
ExternalActionChunk w = (ExternalActionChunk)World.GetActionChunk((double)rand.Next(12));
var p = World.GetDimensionValuePair("Current P", FactoryOutput(i, (double)w.LabelAsIComparable));
ExternalActionChunk w1 = (ExternalActionChunk)World.GetActionChunk(Math.Round((target + p.Value + NoiseOptions[rand.Next(3)]) / 2));
FixedRule mfr = AgentInitializer.InitializeActionRule(John, FixedRule.Factory, w1, MemoryGroup_SupportCalculator);
mfr.GeneralizedCondition.Add(p, true);
mfr.GeneralizedCondition.Add(w, true);
John.Commit(mfr);
}
goto default;
case Groups.SIMPLE_RULE:
for (double i = 0; i < 12; i++)
{
FixedRule sfr = AgentInitializer.InitializeActionRule(John, FixedRule.Factory, World.GetActionChunk(i), SimpleRule_SupportCalculator);
John.Commit(sfr);
}
goto default;
default:
idn.Parameters.LEARNING_RATE = .05;
idn.Parameters.DISCOUNT = .95;
John.ACS.Parameters.SELECTION_TEMPERATURE = .09;
idn.Parameters.POSITIVE_MATCH_THRESHOLD = 1;
RefineableActionRule.GlobalParameters.GENERALIZATION_THRESHOLD_1 = 2;
RefineableActionRule.GlobalParameters.SPECIALIZATION_THRESHOLD_1 = 1.2;
RefineableActionRule.GlobalParameters.POSITIVE_MATCH_THRESHOLD = 1;
threshold_4 = .2;
break;
}
RefineableActionRule.GlobalParameters.INFORMATION_GAIN_OPTION = RefineableActionRule.IGOptions.PERFECT;
John.Commit(idn);
}
