public static void PreTrainACS(BPNetwork idn)
{
Console.Write("Pre-training ACS...");
pABEBlackGun = abeBlackGun + (((r.NextDouble() * 2) - 1) * abeMaxTemp);
pABEWhiteGun = abeWhiteGun + (((r.NextDouble() * 2) - 1) * abeMaxTemp);
List <ActivationCollection> dataSets = new List <ActivationCollection>();
List <DeclarativeChunk> primes = new List <DeclarativeChunk>();
primes.AddRange(white_faces);
primes.AddRange(black_faces);
List <DeclarativeChunk> targets = new List <DeclarativeChunk>();
targets.AddRange(guns);
targets.AddRange(tools);
foreach (DeclarativeChunk p in primes)
{
foreach (DeclarativeChunk t in targets)
{
ActivationCollection ds = ImplicitComponentInitializer.NewDataSet();
ds.AddRange(p, 1);
ds.AddRange(t, 1);
dataSets.Add(ds);
}
}
ImplicitComponentInitializer.Train(idn, trainer, numIterations: numTrainingTrials, randomTraversal: true, dataSets: dataSets.ToArray());
Console.WriteLine("Finished");
}
static void SetupBPNetwork(Agent reasoner)
{
//Chunks for the whales, tuna, and bears
DeclarativeChunk TunaChunk = World.NewDeclarativeChunk("Tuna");
DeclarativeChunk WhaleChunk = World.NewDeclarativeChunk("Whale");
DeclarativeChunk BearChunk = World.NewDeclarativeChunk("Bear");
//The 2 properties (as DV pairs)
DimensionValuePair livesinwater = World.NewDimensionValuePair("lives in", "water");
DimensionValuePair eatsfish = World.NewDimensionValuePair("eats", "fish");
//The BP network to be used in the bottom level of the NACS
BPNetwork net = AgentInitializer.InitializeAssociativeMemoryNetwork(reasoner, BPNetwork.Factory);
//Adds the properties (as inputs) and chunks (as outputs) to the BP network
net.Input.Add(livesinwater);
net.Input.Add(eatsfish);
net.Output.Add(TunaChunk);
net.Output.Add(WhaleChunk);
net.Output.Add(BearChunk);
reasoner.Commit(net);
//Adds the chunks to the GKS
reasoner.AddKnowledge(TunaChunk);
reasoner.AddKnowledge(WhaleChunk);
reasoner.AddKnowledge(BearChunk);
//Initializes a trainer to use to train the BP network
GenericEquation trainer = ImplicitComponentInitializer.InitializeTrainer(GenericEquation.Factory, (Equation)trainerEQ);
//Adds the properties (as inputs) and chunks (as outputs) to the trainer
trainer.Input.Add(livesinwater);
trainer.Input.Add(eatsfish);
trainer.Output.Add(TunaChunk);
trainer.Output.Add(WhaleChunk);
trainer.Output.Add(BearChunk);
trainer.Commit();
//Sets up data sets for each of the 2 properties
List <ActivationCollection> sis = new List <ActivationCollection>();
ActivationCollection si = ImplicitComponentInitializer.NewDataSet();
si.Add(livesinwater, 1);
sis.Add(si);
si = ImplicitComponentInitializer.NewDataSet();
si.Add(eatsfish, 1);
sis.Add(si);
Console.Write("Training AMN...");
//Trains the BP network to report associative knowledge between the properties and the chunks
ImplicitComponentInitializer.Train(net, trainer, sis, ImplicitComponentInitializer.TrainingTerminationConditions.SUM_SQ_ERROR);
Console.WriteLine("Finished!");
}
public static void Demo()
{
PCANetwork network = PCANetwork.Create(64, 8);
var dataSet = DataGenerator.GenerateDataSet1();
var pca = new PCA(network, 0.7);
PCATrainer trainer = new PCATrainer(network, 50, pca, 0.00000005);
Normalizer3 normalizer = new Normalizer3();
//Normalizer normalizer = new Normalizer();
normalizer.Fit(dataSet.XList);
var normalizedX = normalizer.Normalize(dataSet.XList);
Utils.DisplayListList(dataSet.XList);
Console.WriteLine("--------------------------");
Utils.DisplayListList(normalizedX);
//Utils.DisplayListList(normalizer.DeNormalize(normalizedX));
trainer.Fit(normalizedX);
List <List <double> > convertedX = trainer.GetConvertedDim(normalizedX);
//convertedX=normalizer.DeNormalize(convertedX);
BPNetwork bpNetwork = BPNetwork.Create(8, new int[] { 4 /*, 4, 3*/ }, 3, ActivationFunction.SIGMOID, ActivationFunction.SIGMOID);
var bp = new BP(bpNetwork, 0.6);
BPTrainer bpTrainer = new BPTrainer(bpNetwork, 2000, bp);
bpTrainer.Fit(convertedX, dataSet.YList);
List <List <double> > predicted_ys = bpTrainer.Predict(convertedX);
CorrectCalculator correctCalculator = new CorrectCalculator();
var convertedPredictValue = NeuronOutputConverter.OrderInteger(predicted_ys);
double correct = correctCalculator.Calculate(convertedPredictValue, dataSet.YList);
Console.WriteLine("Score: {0}%", correct * 100);
}
static void DoTraining(BPNetwork target, FoodDrive foodDr)
{
DriveEquation trainer = ImplicitComponentInitializer.InitializeTrainer(DriveEquation.Factory, foodDr);
trainer.Commit();
List <ActivationCollection> data = new List <ActivationCollection>();
data.Add(ImplicitComponentInitializer.NewDataSet());
foreach (var i in foodDr.Input)
{
ImplicitComponentInitializer.AddRange(i.WORLD_OBJECT, 0, 1, .25);
data[0].Add(i);
}
Console.WriteLine("Performing Pre-Training (see the trace log for results)");
ImplicitComponentInitializer.Train(target, trainer, data, ImplicitComponentInitializer.TrainingTerminationConditions.BOTH, numTrials);
}
public static void Demo()
{
//BPNetwork network = BPNetwork.Create(1, new int[] { 1/*, 4, 3*/ }, 2, ActivationFunction.SIGMOID, ActivationFunction.SIGMOID);
BPNetwork network = BPNetwork.Create(32, new int[] { 10 /*, 4, 3*/ }, 1, ActivationFunction.SIGMOID, ActivationFunction.SIGMOID);
network.Display();
//var dataSet = DataGenerator.GenerateDataSet1();
var dataSet = DataGenerator.GenerateDataSet1_2();
var bp = new BP(network, 0.6);
BPTrainer trainer = new BPTrainer(network, 500, bp);
trainer.Fit(dataSet.XList, dataSet.YList);
List <List <double> > predicted_ys = trainer.Predict(dataSet.XList);
Console.WriteLine("Network Outputs: ");
foreach (var ys in predicted_ys)
{
Console.Write(" ");
foreach (var y in ys)
{
Console.Write(y);
Console.Write(", ");
}
Console.WriteLine();
}
network.Display();
CorrectCalculator correctCalculator = new CorrectCalculator();
var convertedPredictValue = NeuronOutputConverter.OrderInteger(predicted_ys);
double correct = correctCalculator.Calculate(convertedPredictValue, dataSet.YList);
Console.WriteLine("Score: {0}%", correct * 100);
StringBuilder sb_epoch = new StringBuilder();
StringBuilder sb_errors = new StringBuilder();
int step = 0;
trainer.Epoch_Errors.ForEach(err => {
sb_epoch.Append(step + ",");
sb_errors.Append(err + ",");
step++;
});
//生成文本数据，拷贝到python中作图
StringBuilder sb = new StringBuilder();
sb.AppendLine("import matplotlib.pyplot as plt");
sb.AppendLine("x1=[" + sb_epoch.ToString().TrimEnd(",".ToCharArray()) + "]");
sb.AppendLine("y1=[" + sb_errors.ToString().TrimEnd(",".ToCharArray()) + "]");
sb.AppendLine("plt.plot(x1,y1,'b^')");
sb.AppendLine("plt.show()");
var file = System.IO.Path.Combine(AppContext.BaseDirectory, "display.py");
File.WriteAllText(file, sb.ToString());
Console.WriteLine("saved to path: " + file);
System.Diagnostics.Process.Start("C:\\ProgramData\\Anaconda3\\envs\\keras\\python.exe", "\"" + file + "\"");
}
public BPTrainer(BPNetwork network, int epoch, BP algorithm) : base(network, epoch, algorithm)
{
this.Epoch_Errors = new List <double>();
}
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);
}
