Esempio n. 1
0
        public override int Run(string[] args)
        {
            Console.WriteLine("Start");
            fill_params(args);
            Console.WriteLine("Params get \nfile in {0} \n", file_in);

            Approx_learn_set = BaseUFSLoader.LoadLearnFromUFS(file_in);
            Console.WriteLine("Tra load");

            Approx_test_set = BaseUFSLoader.LoadTestFromUFS(file_in);
            Console.WriteLine("Tst load");
            conf = new PSOBacterySearchConf();
            conf.Init(Approx_learn_set.CountVars);
            conf.loadParams(confParams);
            Console.WriteLine("Conf Filed");

            Approx_Singletone = new SAFuzzySystem(Approx_learn_set, Approx_test_set);
            Approx_Singletone = SAFSUFSLoader.loadUFS(Approx_Singletone, file_in);

            Console.WriteLine("Classifier created");
            optimaze          = new PSOMethods.Approx.Term_config_PSO_Bactery();
            Approx_Singletone = optimaze.TuneUpFuzzySystem(Approx_Singletone, conf);
            Console.WriteLine("Optimization complite");
            SAFSUFSWriter.saveToUFS(Approx_Singletone, file_out);
            Console.WriteLine("Saved");
            return(1);
        }
Esempio n. 2
0
        public override int Run(string[] args)
        {
            Console.WriteLine("Start");
            fill_params(args);
            Console.WriteLine("Params get \nfile in {0} \n", file_in);

            Class_learn_set = BaseUFSLoader.LoadLearnFromUFS(file_in);
            Console.WriteLine("Tra load");

            Class_test_set = BaseUFSLoader.LoadTestFromUFS(file_in);
            Console.WriteLine("Tst load");
            conf = new PSOBacterySearchConf();
            conf.Init(Class_learn_set.CountVars);
            conf.loadParams(confParams);
            Console.WriteLine("Conf Filed");

            Class_Pittsburg = new PCFuzzySystem(Class_learn_set, Class_test_set);
            Class_Pittsburg = PCFSUFSLoader.loadUFS(Class_Pittsburg, file_in);

            Console.WriteLine("Classifier created");
            optimaze        = new Term_config_PSO_Bactery();
            Class_Pittsburg = optimaze.TuneUpFuzzySystem(Class_Pittsburg, conf);
            Console.WriteLine("Optimization complite");
            PCFSUFSWriter.saveToUFS(Class_Pittsburg, file_out);
            Console.WriteLine("Saved");
            return(1);
        }
        public override ILearnAlgorithmConf getConf(int CountFeatures)
        {
            ILearnAlgorithmConf result = new PSOBacterySearchConf();

            result.Init(CountFeatures);
            return(result);
        }
      public override void Init(ILearnAlgorithmConf Config)
      {
          base.Init(Config);
          PSOBacterySearchConf CurrentConf = Config as PSOBacterySearchConf;

          count_particle = CurrentConf.PSOSCPopulationSize;
          sendBactery    = CurrentConf.PSOBacteryHOCountGet;
          sendPSO        = CurrentConf.PSOBacteryHOCountSend;
          interPSOtoSend = CurrentConf.PSOBacteryHOCountChange;
      }
        public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approximate, ILearnAlgorithmConf conf)
        {
            PSOBacterySearchConf CurrentConf = conf as PSOBacterySearchConf;

            count_iteration = CurrentConf.PSOSCCountIteration;
            c1             = CurrentConf.PSOSCC1;
            c2             = CurrentConf.PSOSCC2;
            w              = 1;
            count_particle = CurrentConf.PSOSCPopulationSize;
            sendBactery    = CurrentConf.PSOBacteryHOCountGet;
            sendPSO        = CurrentConf.PSOBacteryHOCountSend;
            interPSOtoSend = CurrentConf.PSOBacteryHOCountChange;
            result         = Approximate;

            X         = new KnowlegeBaseSARules[count_particle];
            V         = new KnowlegeBaseSARules[count_particle];
            Pi        = new KnowlegeBaseSARules[count_particle];
            Pg        = new KnowlegeBaseSARules();
            Errors    = new double[count_particle];
            OldErrors = new double[count_particle];
            rnd       = new Random();


            preIterate(result);
            int trySend     = 0;
            int counterIter = 0;

            for (int i = 0; i < count_iteration; i++)
            {
                oneIterate(result);
                counterIter++;
                if (counterIter == interPSOtoSend)
                {
                    Pi = sortSolution(Pi);
                    savetoUFS(Pi.ToList(), 0, sendPSO, trySend);
                    BacteryRunner();
                    trySend++;

                    List <KnowlegeBaseSARules> tempRes = loadDatabase().ToList();

                    int size = tempRes.Count;
                    for (int p = tempRes.Count - 1; p >= 0; p--)
                    {
                        X[p] = tempRes[0];

                        double newError = Approximate.approxLearnSamples(X[p]);

                        if (newError < Errors[p])
                        {
                            Pi[p]        = new KnowlegeBaseSARules(X[p]);
                            OldErrors[p] = Errors[p];
                            Errors[p]    = newError;

                            if (minError > newError)
                            {
                                minError = newError;
                                Pg       = new KnowlegeBaseSARules(X[p]);
                            }
                        }

                        tempRes.RemoveAt(0);
                    }

                    counterIter = 0;
                }
            }
            result.RulesDatabaseSet[0].TermsSet.Trim();
            return(result);
        }