static void Main(string[] args)
{
RandomPool.Declare("envset", 0);
//RandomPool.Get();
NetworkGenerator generator = new WSmodelNetworkGenerator(100, 8, 0.12);
generator.NodeCreate += () => new Node();
// = generator.NodeCreate += createNode;
Network net = generator.create();
//Console.WriteLine(net);
//NetworkGenerator generator2 = new LeaderNetworkGenerator(100, 8, 0.12, 30);
//環境を作る
//generator2.NodeCreate += () => new Node();
//Network leaderNet = generator2.create();
//double c = LeaderNetworkGenerator.cluster(leaderNet.Nodes.ElementAt(0),leaderNet);
//Console.WriteLine(leaderNet);
for (int i = 0; i < net.Nodes.Count(); i++)
{
double C = WSmodelNetworkGenerator.cluster(net.Nodes.ElementAt(i), net);
Console.Write("clusters{0} = ", i);
Console.WriteLine(+C);
}
}
public void PlaySteps(int steps, int playstep_seed)
{
RandomPool.Declare(SeedEnum.PlayStepSeed, playstep_seed);
for (int i = 0; i < steps; i++)
{
this.MyAlgo.PlayOneStep(this.MyNetwork, this.MyAgentSet, InfoEnum.Green, InfoEnum.Red);
}
}
public I_AgentSet Generate(int agent_seed, AgentInitMode mode)
{
List <I_Agent> agent_list = new List <I_Agent>();
RandomPool.Declare(SeedEnum.AgentSeed, agent_seed);
foreach (var node in this.MyNetwork.NodeList)
{
var agent = new AgentFactory().Generate(node, this.InitOpinion, this.GreenSigma, this.RedSigma, mode);
agent_list.Add(agent);
}
return(new BaseAgentSet(agent_list, agent_seed));
}
public I_Network Generate(int network_seed, bool seed_enable)
{
RandomPool.Declare(SeedEnum.LayoutSeed, network_seed);
var state = 0;
switch (state)
{
case 0:
Console.WriteLine("-----");
Console.WriteLine("ok Start Network Generation");
var delete_success = ConvertNetwork.DeleteNetworkOutput();
if (!delete_success)
{
goto default;
}
var python_success = this.RawGenerate(network_seed, seed_enable);
if (!python_success)
{
goto default;
}
var raw_edge_list = ConvertNetwork.GetRawEdgeList();
var node_num = ConvertNetwork.GetRawNodeNum();
var network_enum = this.MyNetworkEnum;
if (raw_edge_list == null || node_num == 0 || network_enum == NetworkEnum.Void)
{
goto default;
}
Console.WriteLine("ok Load Raw Network");
Console.WriteLine("ok Node: " + node_num);
Console.WriteLine("ok Edge: " + raw_edge_list.Count);
Console.WriteLine("ok NetworkEnum: " + network_enum.ToString());
Console.WriteLine("ok Network Seed: " + network_seed);
var network = new NetworkFactory().Generate(node_num, raw_edge_list, network_enum, network_seed);
if (network == null)
{
goto default;
}
Console.WriteLine("ok Success Network Generation");
return(network);
default:
Console.WriteLine("no Failure Network Generation");
return(null);
}
}
public void Run()
{
this.MakeFileAndFolder();
RandomPool.Declare(SeedEnum.RoundSeed, this.RoundSeed);
RandomPool.Declare(SeedEnum.PlayStepSeed, this.RoundSeed);
Console.WriteLine(this.PrintObject());
this.MyAlgo.MyOSMLog.StartRecordRounds(this.OutputRoundFilePath);
for (int current_round = 1; current_round <= this.TotalRounds; current_round++)
{
this.MyAlgo.RunOneRound(this.MyNetwork, this.MyAgentSet, current_round, this.RoundSteps);
}
this.MyAlgo.MyOSMLog.StopRecordRounds();
}
public void StartRound(int?seed = null)
{
//ラウンドの数字を進める
Round++;
//ステップははじめにもどす
Step = 0;
//何も渡されなければ、ラウンドIDをシードにする。
if (seed == null)
{
seed = Round;
}
RandomPool.Declare("sensor", seed.Value);
}
public void SetSensorSeed(int s)
{
RandomPool.Declare("sensor", s);//ちゃんとinitEnvでseedの設定してるよ
}
public void SetFactSeed(int s)
{
RandomPool.Declare("fact", s);//ちゃんとinitEnvでseedの設定してるよ
}
public void SetEnvsetSeed(int s)
{
RandomPool.Declare("envset", s);//ちゃんとinitEnvでseedの設定してるよ
}
static void AutoExperiment()
{
//ディレクトリを作成
L.gDirectory(DateTime.Now.ToString("yyyyMMdd_HHmmss"));
L.gDefine("stepbelief,roundacc,aveacc,time,env");
//集団規模のリスト
//int[] sizeList = { 100, 250, 500, 750, 1000, 1500, 2000, 2500 };
int[] sizeList = { 100, 1000 };
//h_trgの種類
double[] h_trgList = { 0.9, 0.94, 0.98, 1.0 };
//expected d <d>
double[] expdList = { 4, 6, 8, 10, 12 };
//シードの種類の個数
int envSeedNum = 10;
var envSeedList = Enumerable.Range(0, envSeedNum);
NodeCreaterCreater AATCC = (double h_trg) => (() => new AAT(h_trg));
NodeCreaterCreater DontReplyCC = (double h_trg) => (() => new DontReply(h_trg));
NodeCreaterCreater NoMoreBeliefCC = (double h_trg) => (() => new NoMoreBelief(h_trg));
NodeCreaterCreater EatingWordsCC = (double h_trg) => (() => new EatingWords(h_trg));
NodeCreaterCreater BelieveOnlySensorCC = (double h_trg) => (() => new BelieveOnlySensor(h_trg));
Dictionary <string, NodeCreaterCreater> creatorList = new Dictionary <string, NodeCreaterCreater> {
//{"AAT", AATCC },
{ "NewDontReply", DontReplyCC },
//{"NoMoreBelief", NoMoreBeliefCC },
//{"BelieveOnlySensor", BelieveOnlySensorCC},
//{"EatingWords", EatingWordsCC },
};
//**************実験条件を表示***************
{
var logAll = L.g("all");
logAll.WriteLine("////////////////////experimental condition ////////////////////");
var dt = DateTime.Now;
string routeDir = dt.ToString("yyyy/MM/dd HH:mm:ss\n");
logAll.WriteLine("Date: " + routeDir);
logAll.WriteLine("AgentNum");
foreach (int size in sizeList)
{
logAll.Write(size + ", ");
}
logAll.WriteLine("\n");
logAll.WriteLine("h_trg");
foreach (double h_trg in h_trgList)
{
logAll.Write(h_trg + ", ");
}
logAll.WriteLine("\n");
logAll.WriteLine("expd");
foreach (int expd in expdList)
{
logAll.Write(expd + ", ");
}
logAll.WriteLine("\n");
logAll.WriteLine("algorithm");
foreach (string creatorName in creatorList.Keys)
{
logAll.Write(creatorName + ", ");
}
logAll.WriteLine("\n");
logAll.WriteLine("envSeedNum: " + envSeedNum);
logAll.WriteLine("\n");
}
//じっけんID
int EXP_ID = 0;
//時間をはかるよ
DateTime prevTime = DateTime.Now;
DateTime startTime = DateTime.Now;
//それぞれのアルゴリズムについて
foreach (var creator in creatorList)
{
//それぞれのサイズについて
foreach (int size in sizeList)
{
//それぞれのh_trgについて
foreach (double h_trg in h_trgList)
{
//それぞれのdについて
foreach (int expd in expdList)
{
//条件を表示
{
L.g("all").WriteLine("");
L.g("all").Write(string.Format("EXP_ID: {0}", EXP_ID++)); //実験IDを
L.g("all").Write(" Algo: " + creator.Key); //アルゴリズムの名前を表示
L.g("all").Write(" agentnum: " + size);
L.g("all").Write(" h_trg: " + h_trg);
L.g("all").Write(" expd: " + expd);
L.g("all").Write(" envSdN: " + envSeedNum);
L.g("all").WriteLine("");
}
//シードの平均をとるため
double[] aveSeedResult = new double[3];
foreach (int envSeed in envSeedList)//環境のシード
{
L.g("roundacc,time,console,stepbelief").Write("\nenvSeed: " + envSeed + " ");
RandomPool.Declare("setenv", envSeed);
{ //実験一回し
RandomPool.Declare("fact", 0); //固定センサー値までばらつかせたら収集がつかんことを学習した。
//環境を作る
NetworkGenerator generator = new SmallworldRingNetworkGenerator(size, expd, 0.12);
generator.NodeCreate += creator.Value(h_trg);
OSEnvironment env = new OSEnvironment(generator, (int)(size * 0.05));
//ファイルにネットワークの情報を表示
L.g("env").WriteLine("" + env);
L.g("env").Flush();
Experiment exp = new Experiment(env);
//実験を実行
var expResult = exp.Run();
{ //平均をとるために和を計算
aveSeedResult[0] += expResult.Correct;
aveSeedResult[1] += expResult.Incorrect;
aveSeedResult[2] += expResult.Undeter;
}
}
{ //時間を表示
DateTime nowTime = DateTime.Now;
TimeSpan tp = nowTime.Subtract(prevTime);
TimeSpan fromStart = nowTime.Subtract(startTime);
L.g("time,console").Write("<span: " + tp); // 処理時間を秒単位で表示
L.g("time,console").WriteLine(" fromStart: " + fromStart + " >"); // 処理時間を秒単位で表示
prevTime = nowTime;
}
}//forenvseed
{ //平均をとる
aveSeedResult[0] /= envSeedNum;
aveSeedResult[1] /= envSeedNum;
aveSeedResult[2] /= envSeedNum;
}
L.g("aveacc,console").WriteLine(
string.Format("SeedAverage: correct: {0} incorrect: {1} undeter: {2}",
aveSeedResult[0], aveSeedResult[1], aveSeedResult[2]));
//ファイルに書き込み
L.Flush();
} //for expd
} //for h_trg
} //for size
} //
} //method AutoExperiment
public void Run()
{
//network
int network_start_seed = 14;
int network_finish_seed = 19;
int total_rounds = 300;
int round_steps = 1500;
int round_seed = 0;
List <int> node_num_list = new List <int> {
600, 700, 800, 900, 1000
};
bool fix_sensor_num = false;
double sensor_rate = 0.1;
int sensor_num = 10;
double rewire_p = 0.01;
int degree = 6;
int attach_edge_num = 2;
int rnd_edge_num = 1;
double triangle_p = 0.01;
double edge_creation_p = 0.01;
//int grid_m = 20;
//int grid_n = 20;
bool seed_enable = true;
//List<NetworkEnum> network_enum_list = new List<NetworkEnum> { NetworkEnum.WS, NetworkEnum.BA, NetworkEnum.ER, NetworkEnum.Grid2D, NetworkEnum.Hexagonal, NetworkEnum.Triangular };
List <NetworkEnum> network_enum_list = new List <NetworkEnum> {
NetworkEnum.Grid2D, NetworkEnum.Hexagonal, NetworkEnum.Triangular
};
I_NetworkGenerator network_generator = null;
//agent
InfoEnum init_op = InfoEnum.Undeter;
//int agent_seed = ;
double g_sigma = 0.9;
double r_sigma = 0.1;
double sensor_acc = 0.55;
double op_intro_rate = 0.1;
int op_intro_duration = 1;
var t_awa_rate = 0.9;
//algo
List <AlgoEnum> algo_enum_list = new List <AlgoEnum> {
AlgoEnum.OriginalAAT, AlgoEnum.AATD_NoTargetH
};
//List<AlgoEnum> algo_enum_list = new List<AlgoEnum> { AlgoEnum.AATD_NoTargetH, AlgoEnum.AATD };
for (int network_seed = network_start_seed; network_seed <= network_finish_seed; network_seed++)
{
foreach (var node_num in node_num_list)
{
foreach (var network_enum in network_enum_list)
{
int grid_m, grid_n;
grid_m = grid_n = 0;
//grid_m = grid_n = (int)Math.Floor(Math.Sqrt(Convert.ToDouble(node_num)));
switch (network_enum)
{
case NetworkEnum.WS:
seed_enable = true;
network_generator = new WS_NetworkGenerator(node_num, degree, rewire_p);
break;
case NetworkEnum.BA:
seed_enable = true;
network_generator = new BA_NetworkGenerator(node_num, attach_edge_num);
break;
case NetworkEnum.ER:
seed_enable = true;
network_generator = new ER_NetworkGenerator(node_num, edge_creation_p);
break;
case NetworkEnum.Grid2D:
grid_m = grid_n = (int)Math.Floor(Math.Sqrt(Convert.ToDouble(node_num)));
seed_enable = false;
network_generator = new Grid2D_NetworkGenerator(grid_m, grid_n);
break;
case NetworkEnum.Hexagonal:
if (node_num == 100)
{
grid_m = grid_n = 6;
}
else if (node_num == 200)
{
grid_m = grid_n = 9;
}
else if (node_num == 300)
{
grid_m = 12;
grid_n = 11;
}
else if (node_num == 400)
{
grid_m = 13;
grid_n = 13;
}
else if (node_num == 500)
{
grid_m = grid_n = 15;
}
else if (node_num == 600)
{
grid_m = 18;
grid_n = 15;
}
else if (node_num == 700)
{
grid_m = 19;
grid_n = 17;
}
else if (node_num == 800)
{
grid_m = 20;
grid_n = 18;
}
else if (node_num == 900)
{
grid_m = 21;
grid_n = 20;
}
else if (node_num == 1000)
{
grid_m = 22;
grid_n = 21;
}
seed_enable = false;
network_generator = new Hexagonal_NetworkGenerator(grid_m, grid_n);
break;
case NetworkEnum.Triangular:
if (node_num == 100)
{
grid_m = 12;
grid_n = 13;
}
else if (node_num == 200)
{
grid_m = 18;
grid_n = 19;
}
else if (node_num == 300)
{
grid_m = 24;
grid_n = 22;
}
else if (node_num == 400)
{
grid_m = 27;
grid_n = 27;
}
else if (node_num == 500)
{
grid_m = grid_n = 30;
}
else if (node_num == 600)
{
grid_m = 32;
grid_n = 34;
}
else if (node_num == 700)
{
grid_m = 36;
grid_n = 36;
}
else if (node_num == 800)
{
grid_m = 39;
grid_n = 38;
}
else if (node_num == 900)
{
grid_m = 42;
grid_n = 40;
}
else if (node_num == 1000)
{
grid_m = 42;
grid_n = 45;
}
seed_enable = false;
network_generator = new Triangular_NetworkGenerator(grid_m, grid_n);
break;
default:
break;
}
var network = network_generator.Generate(network_seed, seed_enable);
I_Layout layout = new Square_LayoutGenerator(network).Generate();
int agent_seed = network_seed;
I_AgentSet agent_set = new BasicAgentSetFactory(network, init_op, g_sigma, r_sigma).Generate(agent_seed, AgentInitMode.Normal);
if (!fix_sensor_num)
{
agent_set.SetSensors((int)(node_num * sensor_rate), sensor_acc);
}
else
{
agent_set.SetSensors(sensor_num, sensor_acc);
}
I_Algo algo = null;
foreach (var algo_enum in algo_enum_list)
{
switch (algo_enum)
{
case AlgoEnum.OriginalAAT:
var gcw = new GeneratingCanWeights();
var ear = new EstimatingAwaRates();
var sws = new SelectingWeiStrategies(t_awa_rate);
var pos = new PlayOneStep(new SendOpinion(op_intro_rate, op_intro_duration), new ReceiveOpinion());
algo = new AAT_Algo(AlgoEnum.OriginalAAT, gcw, ear, sws, pos);
break;
case AlgoEnum.HCII_AATD:
var hcii_aatd_gcw = new GeneratingCanWeights();
var hcii_aatd_ear = new HCII_AATD_EstimatingAwaRates();
var hcii_sws = new SelectingWeiStrategies(t_awa_rate);
var hcii_aatd_pos = new PlayOneStep(new SendOpinion(op_intro_rate, op_intro_duration), new ReceiveOpinion());
algo = new AAT_Algo(AlgoEnum.HCII_AATD, hcii_aatd_gcw, hcii_aatd_ear, hcii_sws, hcii_aatd_pos);
break;
case AlgoEnum.AATD:
var aatd_gcw = new GeneratingCanWeights();
var aatd_ear = new AATD_EstimatingAwaRates();
var aatd_sws = new AATD_SelectingWeiStrategies(t_awa_rate, 2, agent_set.AgentList.Count);
var aatd_pos = new PlayOneStep(new SendOpinion(op_intro_rate, op_intro_duration), new ReceiveOpinion());
algo = new AAT_Algo(AlgoEnum.AATD, aatd_gcw, aatd_ear, aatd_sws, aatd_pos);
break;
case AlgoEnum.AATD_NoTargetH:
var aatd_noth_gcw = new GeneratingCanWeights();
var aatd_noth_ear = new AATD_EstimatingAwaRates();
var aatd_noth_sws = new AATD_SelectingWeiStrategies(1.0, 2, agent_set.AgentList.Count);
var aatd_noth_pos = new PlayOneStep(new SendOpinion(op_intro_rate, op_intro_duration), new ReceiveOpinion());
algo = new AAT_Algo(AlgoEnum.AATD, aatd_noth_gcw, aatd_noth_ear, aatd_noth_sws, aatd_noth_pos);
break;
}
I_OSM osm = new BaseOSM();
osm.MyNetwork = network;
osm.MyAgentSet = agent_set;
osm.MyAlgo = algo;
osm.Initialize();
this.MakeFile(network_enum, node_num, network_seed, algo_enum);
RandomPool.Declare(SeedEnum.RoundSeed, round_seed);
RandomPool.Declare(SeedEnum.PlayStepSeed, round_seed);
//Console.WriteLine(this.PrintObject());
osm.MyAlgo.MyOSMLog.StartRecordRounds(this.OutputRoundFilePath);
for (int current_round = 1; current_round <= total_rounds; current_round++)
{
osm.MyAlgo.RunOneRound(osm.MyNetwork, osm.MyAgentSet, current_round, round_steps);
}
osm.MyAlgo.MyOSMLog.StopRecordRounds();
}
}
}
}
}
public void RunRoundWithoutPlaySteps(int current_round, int runround_seed)
{
RandomPool.Declare(SeedEnum.RoundSeed, runround_seed);
this.MyAlgo.RunOneRoundWithoutPlaySteps(this.MyNetwork, this.MyAgentSet, current_round);
}
