public void InitializePlaySteps(I_Network network, I_AgentSet agent_set)
{
agent_set.InitBelief();
agent_set.InitOpinion();
agent_set.InitCounts();
this.MyPlayOneStep.Initialize();
}
async private void buttonRunLearning_Click(object sender, EventArgs e)
{
var total_rounds = (int)this.numericUpDownAllRounds.Value;
var round_steps = (int)this.numericUpDownAllSteps.Value;
var round_seed = (int)this.numericUpDownLearningSeed.Value;
I_Network network = this.MyOSM.MyNetwork;
I_Algo algo = this.MyOSM.MyAlgo;
I_AgentSet agent_set = this.MyOSM.MyAgentSet;
if (network == null || algo == null || agent_set == null)
{
return;
}
this.MyOSM.Initialize();
this.IsLearning = true;
await Task.Run(() =>
{
//var exp = new Exp_NoExperiment(total_rounds, round_steps, round_seed, this.MyOSM);
//exp.Run();
this.MyOSM.RunRounds(total_rounds, round_steps, round_seed);
this.MyMF.MyAnimationForm.UpdatePictureBox();
});
this.IsLearning = false;
}
public void RunOneRoundWithoutPlaySteps(I_Network network, I_AgentSet agent_set, int current_round)
{
foreach (var agent in agent_set.AgentList)
{
if (agent.IsChanged)
{
agent.ChangedRoundList.Add(current_round);
}
if (agent.IsReceived)
{
agent.ReceiveRoundList.Add(current_round);
}
}
this.MyOSMLog.RecordOneRound(network, agent_set, current_round);
this.EstAwaRates.Run(agent_set, this.CandidateSetList, current_round);
this.SlctWeiStrategies.Run(this.CandidateSetList, agent_set, current_round);
var weight_list = this.CandidateSetList.Select(can => can.GetCanWeight(can.SelectCanIndex)).ToList();
agent_set.SetWeightList(weight_list);
agent_set.InitBelief();
agent_set.InitOpinion();
agent_set.InitCounts();
this.MyPlayOneStep.Initialize();
}
public void Run(List <I_CandidateSet> canset_list, I_AgentSet agent_set, int current_round)
{
foreach (var canset in canset_list)
{
//small -> big
var SortCanset = canset.SingleCandidateList.OrderBy(can => can.CanWeight).ToList();
var l = SortCanset.IndexOf(canset.GetSelectCandidate());
var h = SortCanset[l].AwaRate;
if ((l + 1 < SortCanset.Count) && h < this.TargetAwaRate)
{
l = l + 1;
}
else if (l > 1)
{
var h_pre = SortCanset[l - 1].AwaRate;
if (h_pre > this.TargetAwaRate)
{
l = l - 1;
}
}
var true_index = SortCanset[l].CanIndex;
canset.SelectCanIndex = true_index;
}
}
public void Run(I_Network network, I_AgentSet agent_set, bool env_send, InfoEnum correct, InfoEnum incorrect)
{
this.SendOpinion.Run(network, agent_set, env_send, correct, incorrect);
var send_message_queue = this.SendOpinion.SendMessageQueue;
this.ReceiveOpinion.ReceiveMessageQueue = send_message_queue;
this.ReceiveOpinion.Run(network, agent_set);
}
public void RunOneRound(I_Network network, I_AgentSet agent_set, int current_round, int round_steps)
{
for (int i = 0; i < round_steps; i++)
{
this.PlayOneStep(network, agent_set, InfoEnum.Green, InfoEnum.Red);
}
this.RunOneRoundWithoutPlaySteps(network, agent_set, current_round);
return;
}
public void Run(I_Network network, I_AgentSet agent_set, bool env_send, InfoEnum correct, InfoEnum incorrect)
{
this.SendMessageQueue = new Queue <I_Message>();
if (env_send)
{
this.SendEnvMessage(network, agent_set, correct, incorrect, this.OpinionIntroductionRate);
}
this.SendAgentMessage(network, agent_set);
}
public void Run(I_AgentSet agent_set, List <I_CandidateSet> canset_list, int current_round)
{
foreach (var agent in agent_set.AgentList)
{
var canset = canset_list[agent.NodeID];
if (!agent.IsReceived)
{
continue;
}
this.UpdateAveAwaRates(current_round, agent, canset);
}
}
public void Run(I_AgentSet agent_set, List <I_CandidateSet> canset_list, int current_round)
{
foreach (var agent in agent_set.AgentList)
{
var canset = canset_list[agent.NodeID];
int obs_u = Math.Abs(agent.ReceiveGreenCounts - agent.ReceiveRedCounts);
if (obs_u == 0)
{
continue;
}
this.UpdateAveAwaRates(current_round, agent, canset);
}
}
public List <I_CandidateSet> Generate(I_Network network, I_AgentSet agent_set)
{
List <I_CandidateSet> canset_list = new List <I_CandidateSet>();
I_CandidateSet canset;
foreach (var node in network.NodeList)
{
canset = new SusceptCandidateSet(node, agent_set.AgentList[node.NodeID], this.StepSize);
canset_list.Add(canset);
}
return(canset_list);
}
public SurpriseIndicatorSet(I_Network network, I_AgentSet agent_set)
{
this.Value = new List <I_SurpriseIndicator>();
double init_value = 0.01;
foreach (var node in network.NodeList)
{
foreach (var nei_id in node.NeighborNodeIDList)
{
this.Value.Add(new SurpriseIndicator(node.NodeID, nei_id, init_value));
}
}
}
public Exp_NoExperiment(int total_rounds, int round_steps, int round_seed, I_OSM osm)
{
this.TotalRounds = total_rounds;
this.RoundSteps = round_steps;
this.RoundSeed = round_seed;
this.MyAlgo = osm.MyAlgo;
this.MyNetwork = osm.MyNetwork;
this.MyAgentSet = osm.MyAgentSet;
this.ExpName = "NoExp";
var dt = DateTime.Now;
this.DataName = dt.ToString("yyyy-MM-dd-HH-mm-ss");
this.BasePath = Environment.CurrentDirectory;
this.OutputFolderPath = this.BasePath + "\\" + OutputLog.BaseLogFolderName + "\\" + this.ExpName + "\\" + this.DataName;
OutputLog.SafeCreateDirectory(this.OutputFolderPath);
}
/// <summary>
/// 生成とラウンド開始時に呼び出してagentsetを初期化．
/// </summary>
/// <param name="network"></param>
/// <param name="agent_set"></param>
public void Initialize(I_Network network, I_AgentSet agent_set)
{
agent_set.InitBelief();
agent_set.InitOpinion();
agent_set.InitCounts();
agent_set.InitRoundInfo();
this.SurpriseIndicatorSet.Initialize();
this.MyPlayOneStep.Initialize();
this.CandidateSetList = GeneCanWeights.Generate(network, agent_set);
this.SurpriseIndicatorSet.SetWeightDicList(this.CandidateSetList, network);
var wei_dic_list = this.SurpriseIndicatorSet.WeightDic;
agent_set.SetInitWeightDicList(wei_dic_list);
}
void SendAgentMessage(I_Network network, I_AgentSet agent_set)
{
foreach (var agent in agent_set.AgentList)
{
if (agent.SendReadyMessageQueue.Count == 0)
{
continue;
}
while (agent.SendReadyMessageQueue.Count > 0)
{
var message = agent.SendReadyMessageQueue.Dequeue();
this.SendMessageQueue.Enqueue(message);
}
}
}
Matrix GetBaseMatrix(I_Network network, I_AgentSet agent_set)
{
this.SetAgentViewList(network);
this.SetEdgeViewList(network, agent_set);
var CentralX = this.pictureBoxAnimation.ClientSize.Width / 2;
var CentralY = this.pictureBoxAnimation.ClientSize.Height / 2;
this.ViewX += CentralX;
this.ViewY += CentralY;
var base_matrix = new Matrix();
base_matrix.Scale(this.ViewScale, this.ViewScale);
base_matrix.Translate(this.ViewX, this.ViewY);
return(base_matrix);
}
public void Initialize(I_Network network, I_AgentSet agent_set)
{
agent_set.InitBelief();
agent_set.InitOpinion();
agent_set.InitCounts();
agent_set.InitRoundInfo();
this.MyPlayOneStep.Initialize();
this.CandidateSetList = GeneCanWeights.Generate(network, agent_set);
var weight_list = this.CandidateSetList.Select(can => can.GetCanWeight(can.InitSelectCanIndex)).ToList();
//weight_list = weight_list.Select(w => 0.8).ToList();
agent_set.SetInitWeightList(weight_list);
}
internal void SetEdgeViewList(I_Network network, I_AgentSet agent_set)
{
this.EdgeViewList = new List <EdgeView>();
foreach (var edge in network.EdgeList)
{
Point s_point = new Point((int)this.AgentViewList[edge.SourceNodeID].X, (int)this.AgentViewList[edge.SourceNodeID].Y);
Point t_point = new Point((int)this.AgentViewList[edge.TargetNodeID].X, (int)this.AgentViewList[edge.TargetNodeID].Y);
Dictionary <int, double> s_wei_dic = null;
Dictionary <int, double> t_wei_dic = null;
if (agent_set != null)
{
s_wei_dic = agent_set.AgentList.First(agent => agent.NodeID == edge.SourceNodeID).WeightDic;
t_wei_dic = agent_set.AgentList.First(agent => agent.NodeID == edge.TargetNodeID).WeightDic;
}
this.EdgeViewList.Add(new EdgeView(s_point, edge.SourceNodeID, t_point, edge.TargetNodeID, edge.EdgeID, s_wei_dic, t_wei_dic));
}
}
public void RecordOneRound(I_Network network, I_AgentSet agent_set, int current_round)
{
int green_count = 0;
int red_count = 0;
int undeter_count = 0;
foreach (var agent in agent_set.AgentList)
{
switch (agent.Opinion)
{
case InfoEnum.Undeter:
undeter_count++;
break;
case InfoEnum.Green:
green_count++;
break;
case InfoEnum.Red:
red_count++;
break;
default:
break;
}
}
double all_count = green_count + red_count + undeter_count;
var list = new List <double>();
list.Add(green_count / all_count);
list.Add(red_count / all_count);
list.Add(undeter_count / all_count);
this.RoundResults.Rows.Add(current_round, list[0], list[1], list[2]);
Console.WriteLine($"round: {current_round,3} green: {list[0]:f3} red: {list[1]:f3} undeter: {list[2]:f3}");
if (!this.IsRecordingRounds)
{
return;
}
OutputLog.OutputLogCSV(this.RoundResults, this.OutputRoundFilePath);
}
void SendEnvMessage(I_Network network, I_AgentSet agent_set, InfoEnum correct, InfoEnum incorrect, double op_intro_rate)
{
this.OpinionIntroCounts++;
if (this.OpinionIntroCounts < this.OpinionIntroductionDuration)
{
return;
}
this.OpinionIntroCounts = 0;
this.EnvOpinionCounts++;
var correct_opinion = correct;
var incorrect_opinion = incorrect;
foreach (var agent in agent_set.AgentList)
{
if (!(agent.IsSensor))
{
continue;
}
if (RandomPool.Get(SeedEnum.PlayStepSeed).NextDouble() > op_intro_rate)
{
continue;
}
var env_info = InfoEnum.Undeter;
if (RandomPool.Get(SeedEnum.PlayStepSeed).NextDouble() < agent.SensorAccuracy)
{
env_info = correct_opinion;
}
else
{
env_info = incorrect_opinion;
}
this.SendMessageQueue.Enqueue(new Message(-1, agent.NodeID, env_info));
}
}
public void PlayOneStep(I_Network network, I_AgentSet agent_set, InfoEnum correct, InfoEnum incorrect)
{
this.MyPlayOneStep.Run(network, agent_set, true, correct, incorrect);
}
public void InitializeRunRounds(I_Network network, I_AgentSet agent_set)
{
this.Initialize(network, agent_set);
}
public void Run(I_Network network, I_AgentSet agent_set)
{
if (this.ReceiveMessageQueue.Count == 0)
{
return;
}
while (this.ReceiveMessageQueue.Count > 0)
{
var message = this.ReceiveMessageQueue.Dequeue();
var target_agent = agent_set.AgentList.First(agent => agent.NodeID == message.TargetNodeID);
var pre_opinion = target_agent.Opinion;
var pre_belief = target_agent.Belief;
double wei = 0;
I_SurpriseIndicator sur_indi = null;
if (message.SourceNodeID < 0)
{
wei = target_agent.SensorAccuracy;
}
else
{
sur_indi = this.SurpriseIndicatorSet.Value.Where(indi => indi.SourceNodeID == message.TargetNodeID).First(indi => indi.TargetNodeID == message.SourceNodeID);
wei = target_agent.WeightDic.First(dic => dic.Key == message.SourceNodeID).Value;
}
var message_op = message.MessageOpinion;
//belief update
if (target_agent.IsSensor)
{
target_agent.Belief = OpinionBeliefUpdater.UpdateBelief(pre_belief, target_agent.SensorAccuracy, message_op);
}
else
{
target_agent.Belief = OpinionBeliefUpdater.UpdateBelief(pre_belief, wei, message_op);
}
if (message.SourceNodeID >= 0)
{
sur_indi.InputOpinion(message_op, target_agent.Belief);
}
if (message_op == InfoEnum.Green)
{
target_agent.ReceiveGreenCounts++;
}
if (message_op == InfoEnum.Red)
{
target_agent.ReceiveRedCounts++;
}
target_agent.IsReceived = (target_agent.InitBelief != target_agent.Belief) ? true : false;
//opinion update
target_agent.Opinion = OpinionBeliefUpdater.UpdateOpinion(pre_opinion, target_agent.Belief, target_agent.GreenSigma, target_agent.RedSigma);
target_agent.IsChanged = (target_agent.InitOpinion != target_agent.Opinion) ? true : false;
var op_change = (pre_opinion != target_agent.Opinion) ? true : false;
//send message
if (op_change)
{
var neighbor_id_list = network.NodeList[target_agent.NodeID].NeighborNodeIDList;
foreach (var nei_id in neighbor_id_list)
{
var new_message = new Message(target_agent.NodeID, nei_id, target_agent.Opinion);
target_agent.SendReadyMessageQueue.Enqueue(new_message);
}
}
}
}
public void Run(List <I_CandidateSet> canset_list, I_AgentSet agent_set, int current_round)
{
int node_id = 0;
foreach (var canset in canset_list)
{
//queue
var agent_queue = this.ChangedQueueList[node_id];
if (agent_queue.Count >= this.QueueRange)
{
agent_queue.Dequeue();
//agent_queue = new Queue<bool>();
}
agent_queue.Enqueue(agent_set.AgentList[node_id].IsChanged);
var changed_count = agent_queue.Count(q => q == true);
var unchanged_count = agent_queue.Count(q => q == false);
//small -> big
var SortCanset = canset.SingleCandidateList.OrderBy(can => can.CanWeight).ToList();
var l = SortCanset.IndexOf(canset.GetSelectCandidate());
var h = SortCanset[l].AwaRate;
if (l + 1 < SortCanset.Count)
{
if (h < this.TargetAwaRate)
{
if (unchanged_count >= changed_count)
{
l = l + 1;
}
}
}
else if (l > 1)
{
var h_pre = SortCanset[l - 1].AwaRate;
if (h_pre > this.TargetAwaRate)
{
if (changed_count > unchanged_count)
{
l = l - 1;
}
}
}
//if (l + 1 < SortCanset.Count)
//{
// if (h < this.TargetAwaRate || unchanged_count >= changed_count)
// {
// l = l + 1;
// }
//}
//else if (l > 1)
//{
// var h_pre = SortCanset[l - 1].AwaRate;
// if (h_pre > this.TargetAwaRate || changed_count > unchanged_count)
// {
// l = l - 1;
// }
//}
var true_index = SortCanset[l].CanIndex;
canset.SelectCanIndex = true_index;
node_id++;
}
}
