Пример #1
0
 public AAT_Algo(AlgoEnum algo_enum, I_GeneratingCanWeights gcw, I_EstimatingAwaRates ear, I_SelectingWeiStrategies sws, I_PlayOneStep pos)
 {
     this.GeneCanWeights    = gcw;
     this.EstAwaRates       = ear;
     this.SlctWeiStrategies = sws;
     this.MyPlayOneStep     = pos;
     this.MyAlgoEnum        = algo_enum;
     this.MyOSMLog          = new OSMLog();
 }
        void MakeFile(NetworkEnum n_enum, int node_num, int n_seed, AlgoEnum a_enum)
        {
            var    di           = new DirectoryInfo(this.OutputFolderPath);
            string condition    = "_nenum." + n_enum.ToString() + "_node." + node_num.ToString() + "_aenum." + a_enum.ToString();
            var    condi_folder = di + "\\" + condition;

            OutputLog.SafeCreateDirectory(condi_folder);
            this.OutputRoundFilePath = OutputLog.SafeCreateCSV(new DirectoryInfo(condi_folder), "RoundOpinion" + condition + "_nseed." + n_seed.ToString());
        }
Пример #3
0
 public IWT_Algo(AlgoEnum algo_enum, I_GeneratingCanWeights gcw, I_EstimatingAwaRates ear, I_SelectingWeiStrategies sws, I_PlayOneStep pos, I_SurpriseIndicatorSet sur_indi_set)
 {
     this.GeneCanWeights       = gcw;
     this.EstAwaRates          = ear;
     this.SlctWeiStrategies    = sws;
     this.MyPlayOneStep        = pos;
     this.MyAlgoEnum           = algo_enum;
     this.MyOSMLog             = new OSMLog();
     this.SurpriseIndicatorSet = sur_indi_set;
 }
Пример #4
0
        public OrdersResponse GetMyOrders(ServersLocation location, AlgoEnum algo)
        {
            var postData = new object[]
            {
                "location=" + (int)location,
                "algo=" + (int)algo
            };

            var data = GetData <NiceHashResponse <OrdersResponse> >(PublicApiCommands.GetOrders, postData);

            return(data.Result);
        }
Пример #5
0
        void Test()
        {
            this.osm_setting = new OSMSetting(ExperimentType.AAT_SW_Normal_Random_Exponential);
            int      agent_size            = osm_setting.agent_size;
            int      dim                   = osm_setting.dim;
            int      correct_dim           = osm_setting.correct_dim;
            int      malicious_dim         = osm_setting.malicious_dim;
            AlgoEnum algo                  = osm_setting.algo;
            double   targeth               = osm_setting.targeth;
            double   common_weight         = osm_setting.common_weight;
            double   common_curiocity      = osm_setting.common_curiocity;
            double   sensor_weight         = osm_setting.sensor_weight;
            double   dist_weight           = osm_setting.dist_weight;
            double   malicious_dist_weight = osm_setting.malicious_dist_weight;
            int      sensor_size           = osm_setting.sensor_size;
            //int malicious_sensor_size = (int)(0.04 * agent_size);
            int malicious_sensor_size = osm_setting.malicious_sensor_size;
            var op_form_threshold     = osm_setting.op_form_threshold;
            int sample_size           = osm_setting.sample_size;
            int change_round          = osm_setting.change_round;

            bool bad_sensor_mode             = osm_setting.bad_sensor_mode;
            int  opinion_share_num           = osm_setting.opinion_share_num;
            bool is_add_share_only_community = osm_setting.add_share_only_community;

            EnvDistributionEnum      env_distribution = osm_setting.env_distribution;
            BeliefUpdateFunctionEnum belief_update    = osm_setting.belief_update;

            var belief_updater = new BeliefUpdater(belief_update).SetSensorWeightMode(SensorWeightEnum.DependSensorRate);

            GraphGeneratorBase graph_generator;

            switch (osm_setting.select_graph)
            {
            case GraphEnum.WS:
                graph_generator = new WS_GraphGenerator().SetNodeSize(agent_size).SetNearestNeighbors(6).SetRewireP(0.01);
                break;

            //case GraphEnum.PowerLawCluster:
            //graph_generator = new PC_GraphGenerator().SetNodeSize(500).SetRandomEdges(3).SetAddTriangleP(0.1);
            // break;
            case GraphEnum.BA:
                graph_generator = new BA_GraphGenerator().SetNodeSize(agent_size).SetAttachEdges(2);
                break;

            case GraphEnum.Grid2D:
                graph_generator = new Grid2D_GraphGenerator().SetNodeSize(agent_size);
                break;

            //case GraphEnum.ER:
            //graph_generator = new ER_GraphGenerator().SetNodeSize(agent_size).SetEdgeCreateP(0.01);
            //break;
            case GraphEnum.LFR:
                graph_generator = new LFR_GraphGenerator().SetNodeSize(agent_size);
                break;

            default:
                graph_generator = new LFR_GraphGenerator().SetNodeSize(agent_size);
                break;
            }
            graph_generator.SetOsmSetting(osm_setting);
            var pb     = new ExtendProgressBar(100);
            var graph  = graph_generator.Generate(0, pb);
            var layout = new KamadaKawai_LayoutGenerator(graph).Generate(pb);
            //var layout = new Circular_LayoutGenerator(graph).Generate();

            //LFRの時のみ
            List <List <int> > communityList = new List <List <int> >();

            if (osm_setting.select_graph == GraphEnum.LFR)
            {
                communityList = graph_generator.GetCommunity();
            }
            var init_belief_gene = new InitBeliefGenerator()
                                   .SetInitBeliefMode(mode: InitBeliefMode.NormalNarrow);
            //.SetInitBeliefMode(mode: InitBeliefMode.NormalWide);

            var subject_test = new OpinionSubject("test", dim);

            var sample_agent_test = new SampleAgent()
                                    .SetInitBeliefGene(init_belief_gene)
                                    .SetThreshold(op_form_threshold)
                                    .SetSubject(subject_test)
                                    .SetInitOpinion(Vector <double> .Build.Dense(dim, 0.0));

            var sensor_gene = new SensorGenerator()
                              //                .SetSensorSize((int)5);
                              .SetSensorSize(sensor_size, malicious_sensor_size);

            int agent_gene_seed = 11;//4
            var agent_gene_rand = new ExtendRandom(agent_gene_seed);


            var agent_network = new AgentNetwork()
                                .SetRand(agent_gene_rand)
                                .GenerateNetworkFrame(graph)
                                //.ApplySampleAgent(sample_agent_1, mode: SampleAgentSetMode.RandomSetRate, random_set_rate: 0.5)
                                //.ApplySampleAgent(sample_agent_2, mode: SampleAgentSetMode.RemainSet)
                                .ApplySampleAgent(sample_agent_test, mode: SampleAgentSetMode.RemainSet)
                                .SetBadSensorMode(osm_setting.bad_sensor_mode)
                                .SetSensorArrange(osm_setting.sensor_arrange)
                                .SetCommnityList(communityList)
                                .GenerateSensor(sensor_gene)
                                .SetLayout(layout);
            var bad_community_index = agent_network.GetBadCommunityIndex();

            int update_step_seed = 1;
            var update_step_rand = new ExtendRandom(update_step_seed);

            OSMBase osm = new OSM_Only();

            switch (algo)
            {
            case AlgoEnum.AAT:
                var osm_aat = new AAT_OSM();
                osm_aat.SetTargetH(targeth);
                osm = osm_aat;
                break;

            default:
                break;
            }
            osm.SetRand(update_step_rand);
            osm.SetAgentNetwork(agent_network, opinion_share_num);
            var subject_mgr_dic = new Dictionary <int, SubjectManager>();

            subject_mgr_dic.Add(0, new SubjectManagerGenerator()
                                .Generate(subject_test, dist_weight, correct_dim, sensor_weight, env_distribution, malicious_dim, malicious_dist_weight));
            //for (int i = 0; i < 1; i++)
            //{
            //  subject_mgr_dic.Add(i * change_round, new SubjectManagerGenerator().Generate(subject_test, dist_weight, i % dim, sensor_rate, EnvDistributionEnum.Turara));
            //}
            osm.SetSubjectManagerDic(subject_mgr_dic);
            osm.SetInitWeightsMode(mode: CalcWeightMode.FavorMyOpinion);
            osm.SetOpinionIntroInterval(osm_setting.op_intro_interval);
            osm.SetOpinionIntroRate(osm_setting.op_intro_rate);
            //osm.SetSensorCommonWeight(0.70);
            osm.SetBeliefUpdater(belief_updater);
            osm.SetAddShareCommunityOnly(is_add_share_only_community);

            osm.SetStopRound(osm_setting.stop_rounds);

            this.MyOSM = osm;
            this.MyAnimationForm.RegistOSM(osm, osm_setting.opinion_share_num, communityList, bad_community_index);
        }
Пример #6
0
        public void LoadData(ServersLocation location, AlgoEnum algo, double profitablePrice)
        {
            var tuple = new Tuple <ServersLocation, AlgoEnum, double>(location, algo, profitablePrice);

            gridControl1.RunLoadDataAsync(tuple);
        }
Пример #7
0
        public OSMSetting(ExperimentType experiment_type)
        {
            common_weight         = 0.5;
            common_curiocity      = 0.5;
            dist_weight           = 0.5;
            malicious_dist_weight = 0; //0.8
            //int malicious_sensor_size = (int)(0.04 * agent_size);
            sample_size   = 1;
            change_round  = 0;
            dim           = 2;
            correct_dim   = 0;
            malicious_dim = 1;
            switch (experiment_type)
            {
            case ExperimentType.OSM_LFR_Bad_Each_Exponential:
                agent_size    = 100;
                algo          = AlgoEnum.OSMonly;
                targeth       = 0.9;
                sensor_weight = 0.8;     //0.8

                malicious_sensor_size = 0;
                op_form_threshold     = 0.9;

                bad_sensor_mode          = true;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Each;
                env_distribution         = EnvDistributionEnum.Exponential;
                belief_update            = BeliefUpdateFunctionEnum.Bayse;
                add_share_only_community = false;

                select_graph = GraphEnum.LFR;
                break;

            case ExperimentType.OSM_LFR_Bad_Each_Shitei_SameOpinionBayse:
                agent_size    = 100;
                algo          = AlgoEnum.OSMonly;
                targeth       = 0.9;
                sensor_weight = 0.8;     //0.8

                malicious_sensor_size = 0;
                op_form_threshold     = 0.9;

                bad_sensor_mode          = true;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Each;
                env_distribution         = EnvDistributionEnum.Shitei;
                belief_update            = BeliefUpdateFunctionEnum.SameOpinionAdjustBayse;
                add_share_only_community = false;

                select_graph = GraphEnum.LFR;
                break;

            case ExperimentType.OSM_LFR_Normal_Each_Exponential:
                agent_size        = 100;
                algo              = AlgoEnum.OSMonly;
                targeth           = 0.9;
                sensor_weight     = 0.8; //0.8
                op_form_threshold = 0.9;

                bad_sensor_mode          = true;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Each;
                env_distribution         = EnvDistributionEnum.Exponential;
                belief_update            = BeliefUpdateFunctionEnum.Bayse;
                add_share_only_community = false;

                select_graph = GraphEnum.LFR;
                break;

            case ExperimentType.AAT_LFR_Bad_Each_Shitei:
                agent_size    = 100;
                algo          = AlgoEnum.AAT;
                targeth       = 0.9;
                sensor_weight = 0.55;     //0.8

                op_form_threshold = 0.9;
                sample_size       = 1;
                change_round      = 0;

                bad_sensor_mode          = true;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Each;
                env_distribution         = EnvDistributionEnum.Shitei;
                belief_update            = BeliefUpdateFunctionEnum.Bayse;
                add_share_only_community = false;

                select_graph = GraphEnum.LFR;
                break;

            case ExperimentType.AAT_LFR_Bad_Each_Exponential:
                agent_size = 100;

                algo              = AlgoEnum.AAT;
                targeth           = 0.9;
                sensor_weight     = 0.8; //0.8
                op_form_threshold = 0.9;

                bad_sensor_mode          = true;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Each;
                env_distribution         = EnvDistributionEnum.Exponential;
                belief_update            = BeliefUpdateFunctionEnum.Bayse;
                add_share_only_community = false;

                select_graph = GraphEnum.LFR;
                break;

            case ExperimentType.AAT_LFR_Bad_Each_Exponential_SameOpinionBayse:
                agent_size = 100;

                algo              = AlgoEnum.AAT;
                targeth           = 0.7;
                sensor_weight     = 0.8; //0.8
                op_form_threshold = 0.9;

                bad_sensor_mode          = true;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Each;
                env_distribution         = EnvDistributionEnum.Exponential;
                belief_update            = BeliefUpdateFunctionEnum.SameOpinionAdjustBayse;
                add_share_only_community = false;

                select_graph = GraphEnum.LFR;
                break;

            case ExperimentType.AAT_LFR_Bad_Each_Shitei_SameOpinionBayse:
                agent_size = 100;

                algo              = AlgoEnum.AAT;
                targeth           = 0.8;
                sensor_weight     = 0.8; //0.8
                op_form_threshold = 0.9;

                bad_sensor_mode          = true;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Each;
                env_distribution         = EnvDistributionEnum.Exponential;
                belief_update            = BeliefUpdateFunctionEnum.SameOpinionAdjustBayse;
                add_share_only_community = false;

                select_graph = GraphEnum.LFR;
                break;

            case ExperimentType.AAT_LFR_Normal_Each_Shitei:
                agent_size        = 100;
                algo              = AlgoEnum.AAT;
                targeth           = 0.9;
                sensor_weight     = 0.55; //0.8
                op_form_threshold = 0.8;

                bad_sensor_mode          = false;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Each;
                env_distribution         = EnvDistributionEnum.Shitei;
                belief_update            = BeliefUpdateFunctionEnum.Bayse;
                add_share_only_community = false;

                select_graph = GraphEnum.LFR;
                break;

            case ExperimentType.AAT_LFR_Normal_Each_Exponential:
                agent_size = 100;
                algo       = AlgoEnum.AAT;
                targeth    = 0.9;

                sensor_weight     = 0.8; //0.8
                op_form_threshold = 0.9;

                bad_sensor_mode          = false;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Each;
                env_distribution         = EnvDistributionEnum.Exponential;
                belief_update            = BeliefUpdateFunctionEnum.Bayse;
                add_share_only_community = false;

                select_graph = GraphEnum.LFR;
                break;

            case ExperimentType.AAT_SW_Normal_Random_Exponential:
                agent_size = 100;

                algo    = AlgoEnum.AAT;
                targeth = 0.9;

                sensor_weight     = 0.8; //0.8
                op_form_threshold = 0.9;


                bad_sensor_mode          = false;
                opinion_share_num        = 1;
                sensor_arrange           = SensorArrangementEnum.Random;
                env_distribution         = EnvDistributionEnum.Exponential;
                belief_update            = BeliefUpdateFunctionEnum.Bayse;
                add_share_only_community = false;

                select_graph = GraphEnum.Grid2D;
                break;
            }
            sensor_size = (int)(0.05 * agent_size);
        }
Пример #8
0
        void Test()
        {
            int      agent_size            = 200;
            int      dim                   = 3;
            int      correct_dim           = 0;
            int      malicious_dim         = 1;
            AlgoEnum algo                  = AlgoEnum.SWTkai;
            double   targeth               = 0.80;
            double   common_weight         = 0.5;
            double   common_curiocity      = 0.5;
            double   sensor_rate           = 0.8;
            double   dist_weight           = 0.5;
            double   malicious_dist_weight = 0.8;
            int      sensor_size           = (int)(0.05 * agent_size);
            //int malicious_sensor_size = (int)(0.04 * agent_size);
            int malicious_sensor_size = 0;
            var op_form_threshold     = 0.8;
            int sample_size           = 10;
            int change_round          = 0;

            var belief_updater = new BeliefUpdater().SetSensorWeightMode(SensorWeightEnum.DependSensorRate);

            GraphGeneratorBase graph_generator;

            //graph_generator = new PC_GraphGenerator().SetNodeSize(500).SetRandomEdges(3).SetAddTriangleP(0.1);
            //graph_generator = new WS_GraphGenerator().SetNodeSize(agent_size).SetNearestNeighbors(6).SetRewireP(0.01);
            //graph_generator = new BA_GraphGenerator().SetNodeSize(agent_size).SetAttachEdges(2);
            graph_generator = new Grid2D_GraphGenerator().SetNodeSize(agent_size);
            //graph_generator = new ER_GraphGenerator().SetNodeSize(agent_size).SetEdgeCreateP(0.01);

            var pb     = new ExtendProgressBar(100);
            var graph  = graph_generator.Generate(0, pb);
            var layout = new KamadaKawai_LayoutGenerator(graph).Generate(pb);
            //var layout = new Circular_LayoutGenerator(graph).Generate();

            var init_belief_gene = new InitBeliefGenerator()
                                   .SetInitBeliefMode(mode: InitBeliefMode.NormalNarrow);
            //.SetInitBeliefMode(mode: InitBeliefMode.NormalWide);

            var subject_test = new OpinionSubject("test", dim);

            var sample_agent_test = new SampleAgent()
                                    .SetInitBeliefGene(init_belief_gene)
                                    .SetThreshold(op_form_threshold)
                                    .SetSubject(subject_test)
                                    .SetInitOpinion(Vector <double> .Build.Dense(dim, 0.0));

            var sensor_gene = new SensorGenerator()
                              //                .SetSensorSize((int)5);
                              .SetSensorSize(sensor_size, malicious_sensor_size);

            int agent_gene_seed = 4;
            var agent_gene_rand = new ExtendRandom(agent_gene_seed);


            var agent_network = new AgentNetwork()
                                .SetRand(agent_gene_rand)
                                .GenerateNetworkFrame(graph)
                                //.ApplySampleAgent(sample_agent_1, mode: SampleAgentSetMode.RandomSetRate, random_set_rate: 0.5)
                                //.ApplySampleAgent(sample_agent_2, mode: SampleAgentSetMode.RemainSet)
                                .ApplySampleAgent(sample_agent_test, mode: SampleAgentSetMode.RemainSet)
                                .GenerateSensor(sensor_gene)
                                .SetLayout(layout);

            int update_step_seed = 0;
            var update_step_rand = new ExtendRandom(update_step_seed);

            OSMBase osm = new OSM_Only();

            switch (algo)
            {
            case AlgoEnum.AAT:
                var osm_aat = new AAT_OSM();
                osm_aat.SetTargetH(targeth);
                osm = osm_aat;
                break;

            case AlgoEnum.AATG:
                var osm_aatg = new AATG_OSM();
                osm_aatg.SetTargetH(targeth);
                osm = osm_aatg;
                break;

            case AlgoEnum.AATfix:
                var osm_aatfix = new AATfix_OSM();
                osm_aatfix.SetTargetH(targeth);
                osm = osm_aatfix;
                break;

            case AlgoEnum.OSMonly:
                var osm_only = new OSM_Only();
                osm_only.SetCommonWeight(common_weight);
                osm = osm_only;
                break;

            case AlgoEnum.IWTori:
                var osm_iwtori = new IWTori_OSM();
                osm_iwtori.SetCommonCuriocity(common_curiocity);
                osm_iwtori.SetTargetH(targeth);
                osm = osm_iwtori;
                break;

            case AlgoEnum.AATparticle:
                var osm_aatpar = new AATparticle_OSM();
                osm_aatpar.SetSampleSize(sample_size);
                osm_aatpar.SetTargetH(targeth);
                osm = osm_aatpar;
                break;

            case AlgoEnum.AATwindow:
                var osm_window = new AATwindow_OSM();
                osm_window.SetTargetH(targeth);
                osm_window.SetAwaRateWindowSize(20);
                osm = osm_window;
                break;

            case AlgoEnum.AATwindowparticle:
                var osm_window_particle = new AATwindow_particle_OSM();
                osm_window_particle.SetTargetH(targeth);
                osm_window_particle.SetAwaRateWindowSize(20);
                osm_window_particle.SetSampleSize(10);
                osm = osm_window_particle;
                break;

            case AlgoEnum.AATfunction:
                var osm_function = new AATfunction_OSM();
                osm_function.SetTargetH(targeth);
                osm_function.SetAwaRateWindowSize(100);
                osm = osm_function;
                break;

            case AlgoEnum.AATfunctioniwt:
                var osm_function_iwt = new AATfunction_iwt_OSM();
                osm_function_iwt.SetCommonCuriocity(common_curiocity);
                osm_function_iwt.SetTargetH(targeth);
                osm_function_iwt.SetAwaRateWindowSize(100);
                osm = osm_function_iwt;
                break;

            case AlgoEnum.SWT:
                var osm_aat_info = new SWT_OSM();
                osm_aat_info.SetTargetH(targeth);
                osm_aat_info.SetAwaRateWindowSize(50);
                osm_aat_info.SetLinkInfoValueWindowSize(50);
                osm_aat_info.SetInfoWeightRate(1.0);
                osm = osm_aat_info;
                break;

            case AlgoEnum.SWTstep:
                var osm_aat_info_step = new SWT_step_OSM();
                osm_aat_info_step.SetTargetH(targeth);
                osm_aat_info_step.SetAwaRateWindowSize(100);
                osm_aat_info_step.SetLinkInfoValueWindowSize(100);
                osm_aat_info_step.SetInfoWeightRate(1.0);
                osm_aat_info_step.SetInfoLearningRate(0.2);
                osm = osm_aat_info_step;
                break;

            case AlgoEnum.SWTkai:
                var osm_swtkai = new SWTkai_OSM();
                osm_swtkai.SetCommonWeight(0.5);
                osm_swtkai.SetLinkInfoValueWindowSize(1000);
                osm = osm_swtkai;
                break;

            case AlgoEnum.GDWTsigW:
                var osm_gdwt_sigw = new GDWT_OSM();
                osm_gdwt_sigw.SetTargetH(targeth);
                osm_gdwt_sigw.SetAwaRateWindowSize(100);
                osm_gdwt_sigw.SetEstimateFunction(new Sigmoid_weight_EstFunc(1.0, 0, 2));
                osm = osm_gdwt_sigw;
                break;

            case AlgoEnum.GDWTsigH:
                var osm_gdwt_sigh = new GDWT_OSM();
                osm_gdwt_sigh.SetTargetH(targeth);
                osm_gdwt_sigh.SetAwaRateWindowSize(100);
                osm_gdwt_sigh.SetEstimateFunction(new Sigmoid_awa_EstFunc(1.0, 0, 3));
                osm = osm_gdwt_sigh;
                break;

            case AlgoEnum.GDWTpowerH:
                var osm_gdwt_powh = new GDWT_OSM();
                osm_gdwt_powh.SetTargetH(targeth);
                osm_gdwt_powh.SetAwaRateWindowSize(100);
                osm_gdwt_powh.SetEstimateFunction(new Power_awa_EstFunc(3.0, 0));
                osm = osm_gdwt_powh;
                break;

            case AlgoEnum.GDWTpowerW:
                var osm_gdwt_poww = new GDWT_OSM();
                osm_gdwt_poww.SetTargetH(targeth);
                osm_gdwt_poww.SetAwaRateWindowSize(100);
                osm_gdwt_poww.SetEstimateFunction(new Power_weight_EstFunc(3.0, 0));
                osm = osm_gdwt_poww;
                break;

            case AlgoEnum.GDWTLinearW:
                var osm_gdwt_linearw = new GDWT_OSM();
                osm_gdwt_linearw.SetTargetH(targeth);
                osm_gdwt_linearw.SetAwaRateWindowSize(100);
                osm_gdwt_linearw.SetEstimateFunction(new Linear_weight_EstFunc(1.0, 1, 0));
                osm = osm_gdwt_linearw;
                break;

            default:
                break;
            }
            osm.SetRand(update_step_rand);
            osm.SetAgentNetwork(agent_network);
            var subject_mgr_dic = new Dictionary <int, SubjectManager>();

            subject_mgr_dic.Add(0, new SubjectManagerGenerator()
                                .Generate(subject_test, dist_weight, correct_dim, sensor_rate, EnvDistributionEnum.Exponential, malicious_dim, malicious_dist_weight));
            //for (int i = 0; i < 1; i++)
            //{
            //  subject_mgr_dic.Add(i * change_round, new SubjectManagerGenerator().Generate(subject_test, dist_weight, i % dim, sensor_rate, EnvDistributionEnum.Turara));
            //}
            osm.SetSubjectManagerDic(subject_mgr_dic);
            osm.SetInitWeightsMode(mode: CalcWeightMode.FavorMyOpinion);
            osm.SetOpinionIntroInterval(10);
            osm.SetOpinionIntroRate(0.1);
            //osm.SetSensorCommonWeight(0.70);
            osm.SetBeliefUpdater(belief_updater);

            this.MyOSM = osm;
            this.MyAnimationForm.RegistOSM(osm);
        }