public Clarion_AGC_Model(Agent MAKaey)
{
World.LoggingLevel = System.Diagnostics.TraceLevel.Off;
this.MAKaey = MAKaey;
NeuralNetwork = AgentInitializer.InitializeImplicitDecisionNetwork(MAKaey, SimplifiedQBPNetwork.Factory);
}
public static void Initialize()
{
World.LoggingLevel = TraceLevel.Off;
John = World.NewAgent("John");
SimplifiedQBPNetwork net = AgentInitializer.InitializeImplicitDecisionNetwork(John, SimplifiedQBPNetwork.Factory);
net.Input.Add(World.NewDimensionValuePair("Boolean 1", true));
net.Input.Add(World.NewDimensionValuePair("Boolean 1", false));
net.Input.Add(World.NewDimensionValuePair("Boolean 2", true));
net.Input.Add(World.NewDimensionValuePair("Boolean 2", false));
net.Output.Add(World.NewExternalActionChunk(true));
net.Output.Add(World.NewExternalActionChunk(false));
John.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
John.ACS.Parameters.SELECTION_TEMPERATURE = .01;
John.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
John.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
John.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 0;
//Tweak these parameters to see the impact each has on accuracy and learning
net.Parameters.LEARNING_RATE = 1;
net.Parameters.MOMENTUM = .02;
John.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = .5;
John.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = .5;
John.Commit(net);
}
private void Initialize()
{
World.LoggingLevel = TraceLevel.Off;
p1 = World.NewDimensionValuePair("Peg", 1);
p2 = World.NewDimensionValuePair("Peg", 2);
p3 = World.NewDimensionValuePair("Peg", 3);
p4 = World.NewDimensionValuePair("Peg", 4);
p5 = World.NewDimensionValuePair("Peg", 5);
mp1 = World.NewExternalActionChunk();
mp2 = World.NewExternalActionChunk();
mp3 = World.NewExternalActionChunk();
mp4 = World.NewExternalActionChunk();
mp5 = World.NewExternalActionChunk();
mp1 += p1;
mp2 += p2;
mp3 += p3;
mp4 += p4;
mp5 += p5;
John = World.NewAgent();
net = AgentInitializer.InitializeImplicitDecisionNetwork(John, SimplifiedQBPNetwork.Factory);
net.Input.Add(p1);
net.Input.Add(p2);
net.Input.Add(p3);
net.Input.Add(p4);
net.Input.Add(p5);
net.Output.Add(mp1);
net.Output.Add(mp2);
net.Output.Add(mp3);
net.Output.Add(mp4);
net.Output.Add(mp5);
net.Parameters.LEARNING_RATE = 1;
net.Parameters.MOMENTUM = .01;
John.Commit(net);
RefineableActionRule.GlobalParameters.GENERALIZATION_THRESHOLD_1 = -.01;
RefineableActionRule.GlobalParameters.SPECIALIZATION_THRESHOLD_1 = -.4;
}
static void Main(string[] args)
{
//Initialize the task
Console.WriteLine("Initializing the Simple Hello World Task");
int CorrectCounter = 0;
int NumberTrials = 10000;
int progress = 0;
World.LoggingLevel = TraceLevel.Off;
TextWriter orig = Console.Out;
StreamWriter sw = File.CreateText("HelloWorldSimple.txt");
DimensionValuePair hi = World.NewDimensionValuePair("Salutation", "Hellow");
DimensionValuePair bye = World.NewDimensionValuePair("Salutation", "Goodbyew");
ExternalActionChunk sayHi = World.NewExternalActionChunk("Hello");
ExternalActionChunk sayBye = World.NewExternalActionChunk("Goodbye");
//Initialize the Agent
Agent John = World.NewAgent("John");
SimplifiedQBPNetwork net = AgentInitializer.InitializeImplicitDecisionNetwork(John, SimplifiedQBPNetwork.Factory);
net.Input.Add(hi);
net.Input.Add(bye);
net.Output.Add(sayHi);
net.Output.Add(sayBye);
John.Commit(net);
net.Parameters.LEARNING_RATE = 1;
John.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
//Run the task
Console.WriteLine("Running the Simple Hello World Task");
Console.SetOut(sw);
Random rand = new Random();
SensoryInformation si;
ExternalActionChunk chosen;
for (int i = 0; i < NumberTrials; i++)
{
si = World.NewSensoryInformation(John);
//Randomly choose an input to perceive.
if (rand.NextDouble() < .5)
{
//Say "Hello"
si.Add(hi, John.Parameters.MAX_ACTIVATION);
si.Add(bye, John.Parameters.MIN_ACTIVATION);
}
else
{
//Say "Goodbye"
si.Add(hi, John.Parameters.MIN_ACTIVATION);
si.Add(bye, John.Parameters.MAX_ACTIVATION);
}
//Perceive the sensory information
John.Perceive(si);
//Choose an action
chosen = John.GetChosenExternalAction(si);
//Deliver appropriate feedback to the agent
if (chosen == sayHi)
{
//The agent said "Hello".
if (si[hi] == John.Parameters.MAX_ACTIVATION)
{
//The agent responded correctly
Trace.WriteLineIf(World.LoggingSwitch.TraceWarning, "John was correct");
//Record the agent's success.
CorrectCounter++;
//Give positive feedback.
John.ReceiveFeedback(si, 1.0);
}
else
{
//The agent responded incorrectly
Trace.WriteLineIf(World.LoggingSwitch.TraceWarning, "John was incorrect");
//Give negative feedback.
John.ReceiveFeedback(si, 0.0);
}
}
else
{
//The agent said "Goodbye".
if (si[bye] == John.Parameters.MAX_ACTIVATION)
{
//The agent responded correctly
Trace.WriteLineIf(World.LoggingSwitch.TraceWarning, "John was correct");
//Record the agent's success.
CorrectCounter++;
//Give positive feedback.
John.ReceiveFeedback(si, 1.0);
}
else
{
//The agent responded incorrectly
Trace.WriteLineIf(World.LoggingSwitch.TraceWarning, "John was incorrect");
//Give negative feedback.
John.ReceiveFeedback(si, 0.0);
}
}
Console.SetOut(orig);
progress = (int)(((double)(i + 1) / (double)NumberTrials) * 100);
Console.CursorLeft = 0;
Console.Write(progress + "% Complete..");
Console.SetOut(sw);
}
//Report Results
Console.WriteLine("Reporting Results for the Simple Hello World Task");
Console.WriteLine("John got " + CorrectCounter + " correct out of " + NumberTrials + " trials (" +
(int)Math.Round(((double)CorrectCounter / (double)NumberTrials) * 100) + "%)");
Console.WriteLine("At the end of the task, John had learned the following rules:");
foreach (var i in John.GetInternals(Agent.InternalContainers.ACTION_RULES))
{
Console.WriteLine(i);
}
sw.Close();
Console.SetOut(orig);
Console.CursorLeft = 0;
Console.WriteLine("100% Complete..");
//Kill the agent to end the task
Console.WriteLine("Killing John to end the program");
John.Die();
Console.WriteLine("John is Dead");
Console.WriteLine("The Simple Hello World Task has finished");
Console.WriteLine("The results have been saved to \"HelloWorldSimple.txt\"");
Console.Write("Press any key to exit");
Console.ReadKey(true);
}
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..
*/
}
public void Init()
{
MyAgent = World.NewAgent(MyHero.Name);
// set up the network and learning parameters for the agent
SimplifiedQBPNetwork net = AgentInitializer.InitializeImplicitDecisionNetwork(MyAgent, SimplifiedQBPNetwork.Factory);
net = AgentInitializer.InitializeImplicitDecisionNetwork(MyAgent, SimplifiedQBPNetwork.Factory);
for (int i = 0; i < HealthInputs.GetLength(0); i++)
{
// net.Input.Add(HealthInputs[i]);
// net.Input.Add(ManaInputs[i]);
}
for (int i = 0; i < InventoryInputs.GetLength(0); i++)
{
for (int j = 0; j < InventoryInputs.GetLength(1); j++)
{
net.Input.Add(InventoryInputs[i, j]);
}
net.Output.Add(PurchaseActions[i]);
}
FixedRule fr;
for (int i = 0; i < PurchaseActions.Length; i++)
{
fr = AgentInitializer.InitializeActionRule(MyAgent, FixedRule.Factory, PurchaseActions[i], ImitativeSupportDelegate);
// fr.GeneralizedCondition.Add(Inputs[i], true);
MyAgent.Commit(fr);
}
// AddRules();
//net.Parameters.LEARNING_RATE = 0.5;
net.Parameters.LEARNING_RATE = 2.0;
// net.Parameters.MOMENTUM = 0.02;
MyAgent.Commit(net);
MyAgent.ACS.Parameters.SELECTION_TEMPERATURE = 0.05;
MyAgent.ACS.Parameters.DELETION_FREQUENCY = 100;
MyAgent.ACS.Parameters.LEVEL_SELECTION_METHOD = ActionCenteredSubsystem.LevelSelectionMethods.COMBINED;
MyAgent.ACS.Parameters.LEVEL_SELECTION_OPTION = ActionCenteredSubsystem.LevelSelectionOptions.FIXED;
// set up the probabilities used to select which system will be chosen to select an action
// at each step (should total 1.0):
// BL - bottom layer (reinforcement learning neural net)
// RER - rule extraction and refinement - extracts rules from the bottom layer
// IRL - independent rule learning - does not use the bottom layer for learning rules
// FR - fixed rules - Clarion cannot change these (though they can be added/removed externally)
// We are currently using fixed rules when we want the agent to immitate the human player and train
// the bottom layer
MyAgent.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 0.33;
MyAgent.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 0.33;
MyAgent.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
MyAgent.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 0.33;
/*
* MyAgent.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 0.75;
* MyAgent.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 0.25;
* MyAgent.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
* MyAgent.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 0;
*/
//MyAgent.ACS.Parameters.VARIABLE_BL_BETA = 0.5;
//MyAgent.ACS.Parameters.VARIABLE_RER_BETA = 0.5;
//MyAgent.ACS.Parameters.VARIABLE_IRL_BETA = 0;
//MyAgent.ACS.Parameters.VARIABLE_FR_BETA = 0;
}
public static void InitializeAgent(Groups gr)
{
Participant = World.NewAgent();
BPNetwork idn = AgentInitializer.InitializeImplicitDecisionNetwork(Participant, BPNetwork.Factory);
idn.Input.AddRange(dvs);
idn.Output.AddRange(acts);
Participant.Commit(idn);
foreach (DeclarativeChunk t in tools)
{
RefineableActionRule a = AgentInitializer.InitializeActionRule(Participant, RefineableActionRule.Factory, World.GetActionChunk("Tool"));
foreach (DimensionValuePair dv in t)
{
a.GeneralizedCondition.Add(dv, true);
}
Participant.Commit(a);
}
foreach (DeclarativeChunk g in guns)
{
RefineableActionRule a = AgentInitializer.InitializeActionRule(Participant, RefineableActionRule.Factory, World.GetActionChunk("Gun"));
foreach (DimensionValuePair dv in g)
{
a.GeneralizedCondition.Add(dv, true);
}
Participant.Commit(a);
}
Participant.ACS.Parameters.PERFORM_RER_REFINEMENT = false;
Participant.ACS.Parameters.PERFORM_DELETION_BY_DENSITY = false;
Participant.ACS.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 1;
Participant.ACS.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 1;
Participant.ACS.Parameters.FIXED_IRL_LEVEL_SELECTION_MEASURE = 0;
Participant.ACS.Parameters.FIXED_FR_LEVEL_SELECTION_MEASURE = 0;
Participant.ACS.Parameters.B = 1;
HonorDrive honor = AgentInitializer.InitializeDrive(Participant, HonorDrive.Factory, r.NextDouble());
GenericEquation hd = AgentInitializer.InitializeDriveComponent(honor, GenericEquation.Factory, (Equation)TangentEquation);
var ins = Drive.GenerateTypicalInputs(honor);
ParameterChangeActionChunk pac = World.NewParameterChangeActionChunk();
pac.Add(Participant.ACS, "MCS_RER_SELECTION_MEASURE", .5);
hd.Input.AddRange(ins);
hd.Parameters.MAX_ACTIVATION = 5;
honor.Commit(hd);
honor.Parameters.DRIVE_GAIN = (gr == Groups.PRIVATE) ? .1 / 5 : .2 / 5;
Participant.Commit(honor);
ParameterSettingModule lpm = AgentInitializer.InitializeMetaCognitiveModule(Participant, ParameterSettingModule.Factory);
ACSLevelProbabilitySettingEquation lpe = AgentInitializer.InitializeMetaCognitiveDecisionNetwork(lpm, ACSLevelProbabilitySettingEquation.Factory, Participant);
lpe.Input.Add(honor.GetDriveStrength());
lpm.Commit(lpe);
Participant.Commit(lpm);
lpm.Parameters.FIXED_BL_LEVEL_SELECTION_MEASURE = 1;
lpm.Parameters.FIXED_RER_LEVEL_SELECTION_MEASURE = 0;
//Pre-train the IDN in the ACS
PreTrainACS(idn);
}
/// <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;
}
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);
}
static void Main(string[] args)
{
//Initialize the task
Console.WriteLine("Initializing the Full Hello World Task");
int CorrectCounter = 0;
int NumberTrials = 20000;
Random rand = new Random();
World.LoggingLevel = TraceLevel.Off;
int progress = 0;
TextWriter orig = Console.Out;
StreamWriter sw = File.CreateText("HelloWorldFull.txt");
DimensionValuePair hi = World.NewDimensionValuePair("Salutation", "Hello");
DimensionValuePair bye = World.NewDimensionValuePair("Salutation", "Goodbye");
ExternalActionChunk sayHi = World.NewExternalActionChunk("Hello");
ExternalActionChunk sayBye = World.NewExternalActionChunk("Goodbye");
GoalChunk salute = World.NewGoalChunk("Salute");
GoalChunk bidFarewell = World.NewGoalChunk("Bid Farewell");
//Initialize the Agent
Agent John = World.NewAgent("John");
SimplifiedQBPNetwork net = AgentInitializer.InitializeImplicitDecisionNetwork(John, SimplifiedQBPNetwork.Factory);
net.Input.Add(salute, "goals");
net.Input.Add(bidFarewell, "goals");
net.Input.Add(hi);
net.Input.Add(bye);
net.Output.Add(sayHi);
net.Output.Add(sayBye);
net.Parameters.LEARNING_RATE = 1;
John.Commit(net);
John.ACS.Parameters.VARIABLE_BL_BETA = .5;
John.ACS.Parameters.VARIABLE_RER_BETA = .5;
John.ACS.Parameters.VARIABLE_IRL_BETA = 0;
John.ACS.Parameters.VARIABLE_FR_BETA = 0;
RefineableActionRule.GlobalParameters.SPECIALIZATION_THRESHOLD_1 = -.6;
RefineableActionRule.GlobalParameters.GENERALIZATION_THRESHOLD_1 = -.1;
RefineableActionRule.GlobalParameters.INFORMATION_GAIN_OPTION = RefineableActionRule.IGOptions.PERFECT;
AffiliationBelongingnessDrive ab = AgentInitializer.InitializeDrive(John, AffiliationBelongingnessDrive.Factory, rand.NextDouble(), (DeficitChangeProcessor)HelloWorldFull_DeficitChange);
DriveEquation abd = AgentInitializer.InitializeDriveComponent(ab, DriveEquation.Factory);
ab.Commit(abd);
John.Commit(ab);
AutonomyDrive aut = AgentInitializer.InitializeDrive(John, AutonomyDrive.Factory, rand.NextDouble(), (DeficitChangeProcessor)HelloWorldFull_DeficitChange);
DriveEquation autd =
AgentInitializer.InitializeDriveComponent(aut, DriveEquation.Factory);
aut.Commit(autd);
John.Commit(aut);
GoalSelectionModule gsm =
AgentInitializer.InitializeMetaCognitiveModule(John, GoalSelectionModule.Factory);
GoalSelectionEquation gse =
AgentInitializer.InitializeMetaCognitiveDecisionNetwork(gsm, GoalSelectionEquation.Factory);
gse.Input.Add(ab.GetDriveStrength());
gse.Input.Add(aut.GetDriveStrength());
GoalStructureUpdateActionChunk su = World.NewGoalStructureUpdateActionChunk();
GoalStructureUpdateActionChunk bu = World.NewGoalStructureUpdateActionChunk();
su.Add(GoalStructure.RecognizedActions.SET_RESET, salute);
bu.Add(GoalStructure.RecognizedActions.SET_RESET, bidFarewell);
gse.Output.Add(su);
gse.Output.Add(bu);
gsm.SetRelevance(su, ab, 1);
gsm.SetRelevance(bu, aut, 1);
gsm.Commit(gse);
John.Commit(gsm);
John.MS.Parameters.CURRENT_GOAL_ACTIVATION_OPTION =
MotivationalSubsystem.CurrentGoalActivationOptions.FULL;
//Run the task
Console.WriteLine("Running the Full Hello World Task");
Console.SetOut(sw);
SensoryInformation si;
ExternalActionChunk chosen;
for (int i = 0; i < NumberTrials; i++)
{
si = World.NewSensoryInformation(John);
si[AffiliationBelongingnessDrive.MetaInfoReservations.STIMULUS, typeof(AffiliationBelongingnessDrive).Name] = 1;
si[AutonomyDrive.MetaInfoReservations.STIMULUS, typeof(AutonomyDrive).Name] = 1;
//Randomly choose an input to perceive.
if (rand.NextDouble() < .5)
{
//Say "Hello"
si.Add(hi, John.Parameters.MAX_ACTIVATION);
si.Add(bye, John.Parameters.MIN_ACTIVATION);
}
else
{
//Say "Goodbye"
si.Add(hi, John.Parameters.MIN_ACTIVATION);
si.Add(bye, John.Parameters.MAX_ACTIVATION);
}
//Perceive the sensory information
John.Perceive(si);
//Choose an action
chosen = John.GetChosenExternalAction(si);
//Deliver appropriate feedback to the agent
if (chosen == sayHi)
{
//The agent said "Hello".
if (si[hi] == John.Parameters.MAX_ACTIVATION)
{
//The agent responded correctly
Trace.WriteLineIf(World.LoggingSwitch.TraceWarning, "John was correct");
//Record the agent's success.
CorrectCounter++;
//Give positive feedback.
John.ReceiveFeedback(si, 1.0);
}
else
{
//The agent responded incorrectly
Trace.WriteLineIf(World.LoggingSwitch.TraceWarning, "John was incorrect");
//Give negative feedback.
John.ReceiveFeedback(si, 0.0);
}
}
else
{
//The agent said "Goodbye".
if (si[bye] == John.Parameters.MAX_ACTIVATION)
{
//The agent responded correctly
Trace.WriteLineIf(World.LoggingSwitch.TraceWarning, "John was correct");
//Record the agent's success.
CorrectCounter++;
//Give positive feedback.
John.ReceiveFeedback(si, 1.0);
}
else
{
//The agent responded incorrectly
Trace.WriteLineIf(World.LoggingSwitch.TraceWarning, "John was incorrect");
//Give negative feedback.
John.ReceiveFeedback(si, 0.0);
}
}
Console.SetOut(orig);
progress = (int)(((double)(i + 1) / (double)NumberTrials) * 100);
Console.CursorLeft = 0;
Console.Write(progress + "% Complete..");
Console.SetOut(sw);
}
//Report Results
Console.WriteLine("Reporting Results for the Full Hello World Task");
Console.WriteLine("John got " + CorrectCounter + " correct out of " + NumberTrials + " trials (" +
(int)Math.Round(((double)CorrectCounter / (double)NumberTrials) * 100) + "%)");
Console.WriteLine("At the end of the task, John had learned the following rules:");
foreach (var i in John.GetInternals(Agent.InternalContainers.ACTION_RULES))
{
Console.WriteLine(i);
}
sw.Close();
Console.SetOut(orig);
Console.CursorLeft = 0;
Console.WriteLine("100% Complete..");
//Kill the agent to end the task
Console.WriteLine("Killing John to end the program");
John.Die();
Console.WriteLine("John is Dead");
Console.WriteLine("The Full Hello World Task has finished");
Console.WriteLine("The results have been saved to \"HelloWorldFull.txt\"");
Console.Write("Press any key to exit");
Console.ReadKey(true);
}