Beispiel #1
0
 public void calc_Error(a_Fuzzy_System error_checker)
 {
     error_checker.Rulles_Database_Set.Add(hrom_vector.Core_Check);
     error_checker.unlaid_protection_fix(error_checker.Count_Rulles_Databases - 1);
     Error = error_checker.approx_Learn_Samples(error_checker.Count_Rulles_Databases - 1);
     error_checker.Rulles_Database_Set.Remove(hrom_vector.Core_Check);
 }
Beispiel #2
0
        public double Calc_Error(a_Fuzzy_System error_checker)
        {
            Individ temp_Best = null;
            double  min_error = double.PositiveInfinity;

            foreach (Individ indiv in the_popualate)
            {
                indiv.calc_Error(error_checker);
                if (min_error > indiv.error)
                {
                    min_error = indiv.error;
                    temp_Best = indiv;
                }
            }


            if (temp_Best != null)
            {
                if (best_individ != null)
                {
                    if (temp_Best.error < best_individ.error)
                    {
                        best_individ = temp_Best;
                    }
                }
                else
                {
                    best_individ = temp_Best;
                }
            }


            return(min_error);
        }
Beispiel #3
0
        public override Fuzzy_system.Approx_Singletone.a_Fuzzy_System TuneUpFuzzySystem(Fuzzy_system.Approx_Singletone.a_Fuzzy_System Approximate, Abstract_learn_algorithm_conf conf)
        {
            Mnk_lib.Mnk_class Mnk_me = new Mnk_lib.Mnk_class();

            double [,,] Extracted_rules  = extract_Rules(Approximate.Rulles_Database_Set[0]);
            double [,] Extracted_Samples = extract_Sample_table(Approximate.Learn_Samples_set);
            double [] Extracted_Samples_out = extract_Sample_table_Out(Approximate.Learn_Samples_set);
            int       count_rules           = Approximate.Count_Rules();
            int       count_samples         = Approximate.Learn_Samples_set.Count_Samples;
            int       count_Vars            = Approximate.Learn_Samples_set.Count_Vars;

            double []           New_consq = new double[count_rules];
            Type_Term_Func_Enum type_Func = Approximate.Rulles_Database_Set[0].Terms_Set[0].Term_Func_Type;
            int type_func = (int)type_Func;

            Mnk_me.mnk_R(Extracted_rules, count_rules, type_func, Extracted_Samples, Extracted_Samples_out, count_samples, count_Vars, out New_consq);

            a_Fuzzy_System Result = Approximate;

            double result_before = Result.approx_Learn_Samples(0);

            double [] Back_consq = Result.Rulles_Database_Set[0].all_conq_of_rules;
            Result.Rulles_Database_Set[0].all_conq_of_rules = New_consq;
            double result_after = Result.approx_Learn_Samples(0);

            if (result_before < result_after)
            {
                Result.Rulles_Database_Set[0].all_conq_of_rules = Back_consq;
            }
            GC.Collect();
            return(Result);
        }
Beispiel #4
0
        private static void write_about_rules(XmlWriter writer, a_Fuzzy_System Approximate)
        {
            writer.WriteStartElement("Rules");
            writer.WriteAttributeString("Count", XmlConvert.ToString(Approximate.Rulles_Database_Set[0].Rules_Database.Count));

            foreach (ARule rule in Approximate.Rulles_Database_Set[0].Rules_Database)
            {
                writer.WriteStartElement("Rule");

                writer.WriteStartElement("Antecedent");
                writer.WriteAttributeString("Count", XmlConvert.ToString(rule.Term_of_Rule_Set.Count));
                foreach (Term term in rule.Term_of_Rule_Set)
                {
                    writer.WriteStartElement("Pair");
                    writer.WriteAttributeString("Variable", Approximate.Learn_Samples_set.Input_Attributes[term.Number_of_Input_Var].Name);
                    writer.WriteAttributeString("Term", XmlConvert.ToString(Approximate.Rulles_Database_Set[0].Terms_Set.IndexOf(term)));
                    writer.WriteEndElement();
                }
                writer.WriteEndElement();

                writer.WriteStartElement("Consequent");
                writer.WriteAttributeString("Value", XmlConvert.ToString(rule.Kons_approx_Value));
                //  writer.WriteAttributeString("CF",XmlConvert.ToString(rule.CF));
                writer.WriteEndElement();

                writer.WriteEndElement();
            }



            writer.WriteEndElement();
        }
Beispiel #5
0
        public static bool save_to_UFS(a_Fuzzy_System Approximate, string file_name)
        {
            XmlWriterSettings settings = new XmlWriterSettings();

            settings.Encoding           = Encoding.UTF8;
            settings.Indent             = true;
            settings.IndentChars        = "\t";
            settings.NewLineChars       = Environment.NewLine;
            settings.NewLineHandling    = NewLineHandling.None;
            settings.OmitXmlDeclaration = false;


            XmlWriter writer = XmlTextWriter.Create(file_name, settings);

            writer.WriteStartElement("FuzzySystem");
            writer.WriteAttributeString("Type", "ApproximatorSingleton");
            write_about_varibles_and_terms(writer, Approximate);
            write_about_rules(writer, Approximate);
            write_about_observation(writer, Approximate);
            write_about_Estimates(writer, Approximate);
            writer.WriteEndElement();
            //   writer.Flush();
            writer.Close();



            return(false);
        }
Beispiel #6
0
        private static void write_about_Estimates(XmlWriter writer, a_Fuzzy_System Approximate)
        {
            writer.WriteStartElement("Estimates");
            if (Approximate.Test_Samples_set != null)
            {
                writer.WriteAttributeString("Count", XmlConvert.ToString(2));
                writer.WriteStartElement("Estimate");
                writer.WriteAttributeString("Table", Approximate.Learn_Samples_set.File_Name.Remove(Approximate.Learn_Samples_set.File_Name.Length - 4, 4));
                writer.WriteAttributeString("Type", "RMSE");
                writer.WriteAttributeString("Value", XmlConvert.ToString(Approximate.approx_Learn_Samples()));
                writer.WriteEndElement();



                writer.WriteStartElement("Estimate");
                writer.WriteAttributeString("Table", Approximate.Test_Samples_set.File_Name.Remove(Approximate.Learn_Samples_set.File_Name.Length - 4, 4));
                writer.WriteAttributeString("Type", "RMSE");
                writer.WriteAttributeString("Value", XmlConvert.ToString(Approximate.approx_Test_Samples()));
                writer.WriteEndElement();
            }
            else
            {
                writer.WriteAttributeString("Count", XmlConvert.ToString(1));
                writer.WriteStartElement("Estimate");
                writer.WriteAttributeString("Table", Approximate.Learn_Samples_set.File_Name.Remove(Approximate.Learn_Samples_set.File_Name.Length - 4, 4));
                writer.WriteAttributeString("Type", "RMSE");
                writer.WriteAttributeString("Value", XmlConvert.ToString(Approximate.approx_Learn_Samples()));
                writer.WriteEndElement();
            }


            writer.WriteEndElement();
        }
Beispiel #7
0
        private static void write_about_varibles_and_terms(XmlWriter writer, a_Fuzzy_System Approximate)
        {
            writer.WriteStartElement("Variables");
            writer.WriteAttributeString("Count", XmlConvert.ToString(Approximate.Count_Vars));


            for (int i = 0; i < Approximate.Count_Vars; i++)
            {
                writer.WriteStartElement("Variable");
                writer.WriteAttributeString("Name", Approximate.Learn_Samples_set.Input_Attributes[i].Name);
                writer.WriteAttributeString("Min",
                                            XmlConvert.ToString(Approximate.Learn_Samples_set.Input_Attributes[i].Min));
                writer.WriteAttributeString("Max",
                                            XmlConvert.ToString(Approximate.Learn_Samples_set.Input_Attributes[i].Max));
                List <Term> terms_for_varrible =
                    Approximate.Rulles_Database_Set[0].Terms_Set.Where(x => x.Number_of_Input_Var == i).ToList();
                writer.WriteStartElement("Terms");
                writer.WriteAttributeString("Count", XmlConvert.ToString(terms_for_varrible.Count));

                foreach (var term in terms_for_varrible)
                {
                    write_about_term(writer, Approximate, term);
                }
                writer.WriteEndElement();
                writer.WriteEndElement();
            }

            writer.WriteEndElement();
        }
Beispiel #8
0
        public override a_Fuzzy_System Generate(Fuzzy_system.Approx_Singletone.a_Fuzzy_System Approximate, Abstract_generator_conf config)
        {
            a_Fuzzy_System result = Approximate;

            if (result.Count_Rulles_Databases == 0)
            {
                result.Init_Rules_everyone_with_everyone(config);
            }

            count_shrink = ((Term_shrink_and_rotate_conf)config).Число_параметров_для_уменьшения_термов;
            size_shrink  = ((Term_shrink_and_rotate_conf)config).Значение_уменьшения_термов;
            type_func    = ((Term_shrink_and_rotate_conf)config).Функция_принадлежности;
            count_slices = ((Term_shrink_and_rotate_conf)config).Количество_термов_для_каждого_признака;



            List <int> Varians_of_run_system = new List <int>();

            for (int i = 0; i < Approximate.Count_Vars; i++)
            {
                int count_terms_for_var = Approximate.Rulles_Database_Set[0].Terms_Set.FindAll(x => x.Number_of_Input_Var == i).Count;
                if (i < count_shrink)
                {
                    Varians_of_run_system.Add(count_terms_for_var - size_shrink);
                }
                else
                {
                    Varians_of_run_system.Add(count_terms_for_var);
                }
            }

            Varians_of_run_system.Sort();
            Type_Term_Func_Enum type_of_term = Approximate.Rulles_Database_Set[0].Terms_Set[0].Term_Func_Type;

            Generate_all_variant_in_pool(Varians_of_run_system);

            for (int i = 0; i < Pull_of_systems.Count; i++)
            {
                Approximate.Rulles_Database_Set.Clear();

                Approximate.Init_Rules_everyone_with_everyone(type_of_term, Pull_of_systems[i].ToArray());
                Systems_ready_to_test.Add(Approximate.Rulles_Database_Set[0]);
                errors_of_systems.Add(result.approx_Learn_Samples(0));
            }

            int best_index = errors_of_systems.IndexOf(errors_of_systems.Min());

            result.Rulles_Database_Set.Clear();
            result.Rulles_Database_Set.Add(Systems_ready_to_test[best_index]);
            Console.WriteLine(Pull_of_systems.Count());



            GC.Collect();
//            result.unlaid_protection_fix();
            return(result);
        }
Beispiel #9
0
        public override a_Fuzzy_System TuneUpFuzzySystem(Fuzzy_system.Approx_Singletone.a_Fuzzy_System Approximate, Abstract_learn_algorithm_conf config)
        {
            a_Fuzzy_System result = Approximate;

            if (result.Count_Rulles_Databases == 0)
            {
                throw new System.FormatException("Что то не то с входными данными");
            }
            Optimize_Term_shrink_and_rotate_conf Config = config as Optimize_Term_shrink_and_rotate_conf;

            count_shrink = Config.Число_параметров_для_уменьшения_термов;
            size_shrink  = Config.Значение_уменьшения_термов;



            List <int> Varians_of_run_system = new List <int>();

            for (int i = 0; i < Approximate.Count_Vars; i++)
            {
                int count_terms_for_var = Approximate.Rulles_Database_Set[0].Terms_Set.FindAll(x => x.Number_of_Input_Var == i).Count;
                if (i < count_shrink)
                {
                    Varians_of_run_system.Add(count_terms_for_var - size_shrink);
                }
                else
                {
                    Varians_of_run_system.Add(count_terms_for_var);
                }
            }

            Varians_of_run_system.Sort();
            Type_Term_Func_Enum type_of_term = Approximate.Rulles_Database_Set[0].Terms_Set[0].Term_Func_Type;

            Generate_all_variant_in_pool(Varians_of_run_system);

            for (int i = 0; i < Pull_of_systems.Count; i++)
            {
                Approximate.Rulles_Database_Set.Clear();

                Approximate.Init_Rules_everyone_with_everyone(type_of_term, Pull_of_systems[i].ToArray());
                Systems_ready_to_test.Add(Approximate.Rulles_Database_Set[0]);
                errors_of_systems.Add(result.approx_Learn_Samples(0));
            }

            int best_index = errors_of_systems.IndexOf(errors_of_systems.Min());

            result.Rulles_Database_Set.Clear();
            result.Rulles_Database_Set.Add(Systems_ready_to_test[best_index]);
            Console.WriteLine(Pull_of_systems.Count());



//            result.unlaid_protection_fix();
            return(result);
        }
        public override Fuzzy_system.Approx_Singletone.a_Fuzzy_System TuneUpFuzzySystem(a_Fuzzy_System Approximate, Abstract_learn_algorithm_conf conf)
        {
            a_Fuzzy_System result = Approximate;

            count_iteration = ((Term_Config_Random_Search_conf)conf).Количество_итераций;
            count_Rules     = ((Term_Config_Random_Search_conf)conf).Количество_генерируемых_баз_правил_за_итерацию;

            for (int i = 0; i < count_iteration; i++)
            {
                int    temp_prev_count_c_Rule = result.Rulles_Database_Set.Count;
                double temp_best_result       = result.approx_Learn_Samples();
                int    temp_best_index        = 0;

                for (int j = 0; j < count_Rules; j++)
                {
                    Knowlege_base_ARules temp_a_Rule = new Knowlege_base_ARules(result.Rulles_Database_Set[0]);
                    result.Rulles_Database_Set.Add(temp_a_Rule);
                    int temp_index = result.Rulles_Database_Set.Count - 1;
                    for (int k = 0; k < result.Rulles_Database_Set[temp_index].Terms_Set.Count; k++)
                    {
                        result.Rulles_Database_Set[temp_index].Terms_Set[k] =
                            randomize_term(result.Rulles_Database_Set[temp_index].Terms_Set[k]);
                    }
                    double[] kons = result.Rulles_Database_Set[temp_index].all_conq_of_rules;
                    for (int k = 0; k < kons.Count(); k++)
                    {
                        kons[k] = GaussRandom.Random_gaussian(rand, kons[k], kons[k] / 10);
                    }
                    result.Rulles_Database_Set[temp_index].all_conq_of_rules = kons;
                    bool   success       = true;
                    double current_score = 0;
                    try
                    {
                        current_score = result.approx_Learn_Samples(temp_index);
                    }
                    catch (Exception)
                    {
                        success = false;
                    }
                    if (success && (current_score >= temp_best_result))
                    {
                        temp_best_result = current_score;
                        temp_best_index  = temp_index;
                    }
                }

                result.Rulles_Database_Set[0] = result.Rulles_Database_Set[temp_best_index];
                result.Rulles_Database_Set.RemoveRange(temp_prev_count_c_Rule, result.Rulles_Database_Set.Count - temp_prev_count_c_Rule);
            }



            GC.Collect();
            return(result);
        }
        public override a_Fuzzy_System Generate(Fuzzy_system.Approx_Singletone.a_Fuzzy_System Approximate, Abstract_generator_conf config)
        {
            start_add_rules = Approximate.Count_Rulles_Databases;
            a_Fuzzy_System result = Approximate;

            if (result.Count_Rulles_Databases == 0)
            {
                result.Init_Rules_everyone_with_everyone(config);
            }



            Request_count_rules = ((Rulles_shrink_conf)config).Нужно_Правил;
            max_count_rules     = ((Rulles_shrink_conf)config).Максимально_Правил;
            count_slices        = ((Rulles_shrink_conf)config).Количество_термов_для_каждого_признака;
            min_count_rules     = ((Rulles_shrink_conf)config).Минимально_Правил;
            type_term           = ((Rulles_shrink_conf)config).Функция_принадлежности;

            int         count_of_swith_off    = ((Rulles_shrink_conf)config).Максимально_Правил - Request_count_rules;
            List <byte> Varians_of_run_system = new List <byte>();

            for (int i = 0; i < Approximate.Rulles_Database_Set[0].Rules_Database.Count; i++)
            {
                Varians_of_run_system.Add(1);
            }
            for (int i = 0; i < count_of_swith_off; i++)
            {
                Varians_of_run_system[i] = 0;
            }
            Generate_all_variant_in_pool(Varians_of_run_system);
            for (int i = 0; i < Pull_of_systems.Count; i++)
            {
                Knowlege_base_ARules temp_rules = new  Knowlege_base_ARules(result.Rulles_Database_Set[0], Pull_of_systems[i]);
                temp_rules.trim_not_used_Terms();

                result.Rulles_Database_Set.Add(temp_rules);
                result.unlaid_protection_fix(start_add_rules + i);
                errors_of_systems.Add(result.approx_Learn_Samples(start_add_rules + i));
            }

            int best_index            = errors_of_systems.IndexOf(errors_of_systems.Min());
            Knowlege_base_ARules best = result.Rulles_Database_Set[start_add_rules + best_index];

            result.Rulles_Database_Set.Clear();
            result.Rulles_Database_Set.Add(best);
            Console.WriteLine(Pull_of_systems.Count());



            GC.Collect();
//            result.unlaid_protection_fix();
            return(result);
        }
Beispiel #12
0
        private void save_FS(a_Fuzzy_System FS, string Name_alg)
        {
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }


            string file_name = DateTime.Now.ToLongDateString() + " " + DateTime.Now.TimeOfDay.ToString("hh','mm','ss") + " (" + Thread.CurrentThread.ManagedThreadId.ToString() + ")" + "[" + Approx_Singletone.value_complexity().ToString() + "]{" + Name_alg + "}.ufs";

            a_FS_UFS_Writer.save_to_UFS(FS, path + file_name);
        }
        public override a_Fuzzy_System TuneUpFuzzySystem(Fuzzy_system.Approx_Singletone.a_Fuzzy_System Approximate, Abstract_learn_algorithm_conf config)
        {
            start_add_rules = Approximate.Count_Rulles_Databases;
            a_Fuzzy_System result = Approximate;

            if (result.Count_Rulles_Databases == 0)
            {
                throw new System.FormatException("Что то не то с входными данными");
            }



            Optimize_Rulles_shrink_conf Config = config as Optimize_Rulles_shrink_conf;

            Request_count_rules = ((Rulles_shrink_conf)config).Нужно_Правил;
            max_count_rules     = ((Rulles_shrink_conf)config).Максимально_Правил;
            min_count_rules     = ((Rulles_shrink_conf)config).Минимально_Правил;

            int         count_of_swith_off    = Config.Максимально_Правил - Request_count_rules;
            List <byte> Varians_of_run_system = new List <byte>();

            for (int i = 0; i < Approximate.Rulles_Database_Set[0].Rules_Database.Count; i++)
            {
                Varians_of_run_system.Add(1);
            }
            for (int i = 0; i < count_of_swith_off; i++)
            {
                Varians_of_run_system[i] = 0;
            }
            Generate_all_variant_in_pool(Varians_of_run_system);
            for (int i = 0; i < Pull_of_systems.Count; i++)
            {
                Knowlege_base_ARules temp_rules = new  Knowlege_base_ARules(result.Rulles_Database_Set[0], Pull_of_systems[i]);
                temp_rules.trim_not_used_Terms();

                result.Rulles_Database_Set.Add(temp_rules);
                result.unlaid_protection_fix(start_add_rules + i);
                errors_of_systems.Add(result.approx_Learn_Samples(start_add_rules + i));
            }

            int best_index            = errors_of_systems.IndexOf(errors_of_systems.Min());
            Knowlege_base_ARules best = result.Rulles_Database_Set[start_add_rules + best_index];

            result.Rulles_Database_Set.Clear();
            result.Rulles_Database_Set.Add(best);
            Console.WriteLine(Pull_of_systems.Count());



//            result.unlaid_protection_fix();
            return(result);
        }
        public override a_Fuzzy_System Generate(a_Fuzzy_System Approximate, Abstract_generator_conf config)
        {
            type_alg            = ((k_mean_rules_generator_conf)config).Алгоритм;
            count_rules         = ((k_mean_rules_generator_conf)config).Количество_правил;
            type_func           = ((k_mean_rules_generator_conf)config).Функция_принадлежности;
            nebulisation_factor = ((k_mean_rules_generator_conf)config).Экспоненциальный_вес_алгоритма;
            Max_iteration       = ((k_mean_rules_generator_conf)config).Итераций;
            need_precision      = ((k_mean_rules_generator_conf)config).Точность;


            k_mean_base K_Agl = null;

            switch (type_alg)
            {
            case Type_k_mean_algorithm.Gath_geva: K_Agl = new k_mean_Gath_Geva(Approximate.Learn_Samples_set, Max_iteration, need_precision, count_rules, nebulisation_factor); break;

            case Type_k_mean_algorithm.Gustafson_Kessel: K_Agl = new k_mean_Gustafson_kessel(Approximate.Learn_Samples_set, Max_iteration, need_precision, count_rules, nebulisation_factor); break;

            case Type_k_mean_algorithm.FCM: K_Agl = new k_mean_base(Approximate.Learn_Samples_set, Max_iteration, need_precision, count_rules, nebulisation_factor); break;
            }
            K_Agl.Calc();

            Knowlege_base_ARules New_Rules = new Knowlege_base_ARules();

            for (int i = 0; i < count_rules; i++)
            {
                int []      order_terms = new int [Approximate.Learn_Samples_set.Count_Vars];
                List <Term> term_set    = new List <Term>();
                for (int j = 0; j < Approximate.Learn_Samples_set.Count_Vars; j++)
                {
                    Term temp_term = Term.Make_Term(K_Agl.Centroid_cordinate_S[i][j], Math.Sqrt(Calc_distance_for_member_ship_function_for_Clust(i, j, K_Agl)) * 3, type_func, j);
                    term_set.Add(temp_term);
                }
                New_Rules.constuct__and_add_the_Rule(term_set, Approximate);
            }

            a_Fuzzy_System Result = Approximate;

            if (Result.Rulles_Database_Set.Count > 0)
            {
                Result.Rulles_Database_Set[0] = New_Rules;
            }
            else
            {
                Result.Rulles_Database_Set.Add(New_Rules);
            }
            Result.unlaid_protection_fix();
            GC.Collect();
            return(Result);
        }
        public override a_Fuzzy_System Generate(a_Fuzzy_System Approximate, Abstract_generator_conf config)
        {
            a_Fuzzy_System result = Approximate;

            init_everyone_with_everyone config1 = config as init_everyone_with_everyone;

            type_func        = config1.Функция_принадлежности;
            count_slice_vars = config1.Количество_термов_для_каждого_признака;
            result.Init_Rules_everyone_with_everyone(type_func, count_slice_vars);



            return(result);
        }
Beispiel #16
0
        private static void write_about_observation(XmlWriter writer, a_Fuzzy_System Approximate)
        {
            writer.WriteStartElement("Observations");
            if (Approximate.Test_Samples_set != null)
            {
                writer.WriteAttributeString("CountTable", XmlConvert.ToString(2));
                write_about_table(writer, Approximate.Learn_Samples_set, Approximate);
                write_about_table(writer, Approximate.Test_Samples_set, Approximate);
            }
            else
            {
                writer.WriteAttributeString("CountTable", XmlConvert.ToString(1));
                write_about_table(writer, Approximate.Learn_Samples_set, Approximate);
            }

            writer.WriteEndElement();
        }
Beispiel #17
0
        public override Fuzzy_system.Approx_Singletone.a_Fuzzy_System TuneUpFuzzySystem(Fuzzy_system.Approx_Singletone.a_Fuzzy_System Approximate, Abstract_learn_algorithm_conf conf)
        {
            count_populate   = ((Es_Config)conf).Особей_в_популяции;
            count_child      = ((Es_Config)conf).Потомки;
            count_iterate    = ((Es_Config)conf).Количество_итераций;
            coef_t1          = ((Es_Config)conf).Коэффициент_t1;
            coef_t2          = ((Es_Config)conf).Коэффициент_t2;
            param_crossover  = ((Es_Config)conf).Вероятность_скрещивания;
            alg_cross        = ((Es_Config)conf).Алгоритм_Скрещивания;
            type_init        = ((Es_Config)conf).Алгоритм_Инициализации;
            count_Multipoint = ((Es_Config)conf).Точек_Скрещивания;
            type_mutate      = ((Es_Config)conf).Алгоритм_Мутации;
            b_ro             = ((Es_Config)conf).Изменение_РО;

            a_Fuzzy_System result   = Approximate;
            Population     main_pop = new Population(count_populate, count_child, result.Count_Vars, result.Learn_Samples_set);

            main_pop.init_first(result.Rulles_Database_Set[0], rand, type_init);
            for (int i = 0; i < count_iterate; i++)
            {
                double inparam = 0;
                switch (alg_cross)
                {
                case Individ.Alg_crossover.Унифицированный: inparam = param_crossover; break;

                case Individ.Alg_crossover.Многоточечный: inparam = count_Multipoint; break;
                }



                main_pop.select_parents_and_crossover(rand, alg_cross, inparam);
                main_pop.mutate_all(rand, coef_t1, coef_t2, type_mutate, b_ro);
                main_pop.union_parent_and_child();
                main_pop.Calc_Error(result);
                main_pop.select_global();
            }
            result.Rulles_Database_Set[0] = main_pop.get_best_database();
            GC.Collect();
            return(result);
        }
Beispiel #18
0
        private static void write_about_term(XmlWriter writer, a_Fuzzy_System Approximate, Term term)
        {
            writer.WriteStartElement("Term");
            writer.WriteAttributeString("Name",
                                        XmlConvert.ToString(Approximate.Rulles_Database_Set[0].Terms_Set.IndexOf(term)));
            switch (term.Term_Func_Type)
            {
            case Type_Term_Func_Enum.Треугольник:
                writer.WriteAttributeString("Type", "Triangle");
                break;

            case Type_Term_Func_Enum.Гауссоида:
                writer.WriteAttributeString("Type", "Gauss");
                break;

            case Type_Term_Func_Enum.Парабола:
                writer.WriteAttributeString("Type", "Parabolic");
                break;

            case Type_Term_Func_Enum.Трапеция:
                writer.WriteAttributeString("Type", "Trapezoid");
                break;
            }

            writer.WriteStartElement("Params");
            for (int i = 0; i < Member_Function.Count_Params_For_Term(term.Term_Func_Type); i++)
            {
                writer.WriteStartElement("Param");

                writer.WriteAttributeString("Number", XmlConvert.ToString(i));
                writer.WriteAttributeString("Value", XmlConvert.ToString(term.Parametrs[i]));
                writer.WriteEndElement();
            }

            writer.WriteEndElement();



            writer.WriteEndElement();
        }
Beispiel #19
0
 abstract public a_Fuzzy_System Generate(a_Fuzzy_System Approximate, Abstract_generator_conf config);
Beispiel #20
0
        public override a_Fuzzy_System Generate(Fuzzy_system.Approx_Singletone.a_Fuzzy_System Approximate, Abstract_generator_conf config)
        {
            Random         rand   = new Random();
            a_Fuzzy_System result = Approximate;

            if (result.Count_Rulles_Databases == 0)
            {
                Knowlege_base_ARules temp_rules = new Knowlege_base_ARules();
                result.Rulles_Database_Set.Add(temp_rules);
            }



            type_term    = ((Generator_Rulles_simple_random_conf)config).Функция_принадлежности;
            stable_terms = (int)((Generator_Rulles_simple_random_conf)config).Тип_Термов;
            count_rules  = ((Generator_Rulles_simple_random_conf)config).Количество_правил;


            for (int j = 0; j < count_rules; j++)
            {
                int[] order = new int[result.Count_Vars];
                Type_Term_Func_Enum temp_type_term;
                if (stable_terms == 0)
                {
                    temp_type_term = type_term;
                }
                else
                {
                    temp_type_term = Generator_type_term();
                }

                List <Term> temp_term_list = new List <Term>();
                for (int k = 0; k < result.Count_Vars; k++)
                {
                    double[] parametrs = new double[Member_Function.Count_Params_For_Term(temp_type_term)];

                    switch (temp_type_term)
                    {
                    case Type_Term_Func_Enum.Треугольник:
                        parametrs[0] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));
                        parametrs[1] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));
                        parametrs[2] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));
                        Array.Sort(parametrs);
                        break;

                    case Type_Term_Func_Enum.Гауссоида: parametrs[0] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));
                        parametrs[1] = (rand.NextDouble() + 0.01) * 0.5 *
                                       (result.Learn_Samples_set.Attribute_Max(k) -
                                        result.Learn_Samples_set.Attribute_Min(k));
                        break;

                    case Type_Term_Func_Enum.Парабола: parametrs[0] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));
                        parametrs[1] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));
                        Array.Sort(parametrs);
                        break;

                    case Type_Term_Func_Enum.Трапеция: parametrs[0] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));
                        parametrs[1] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));
                        parametrs[2] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));
                        parametrs[3] = result.Learn_Samples_set.Attribute_Min(k) + rand.NextDouble() * (result.Learn_Samples_set.Attribute_Max(k) - result.Learn_Samples_set.Attribute_Min(k));

                        Array.Sort(parametrs);

                        break;
                    }
                    Term temp_term = new Term(parametrs, temp_type_term, k);
                    result.Rulles_Database_Set[0].Terms_Set.Add(temp_term);
                    temp_term_list.Add(temp_term);
                    order[k] = result.Rulles_Database_Set[0].Terms_Set.Count - 1;
                }
                double approx_Value = result.Nearest_Approx(temp_term_list);
                ARule  temp_Rule    = new ARule(result.Rulles_Database_Set[0].Terms_Set, order, approx_Value);
                result.Rulles_Database_Set[0].Rules_Database.Add(temp_Rule);
            }



            result.unlaid_protection_fix();
            GC.Collect();
            return(result);
        }
Beispiel #21
0
        public static a_Fuzzy_System load_UFS(string file_name)
        {
            a_Fuzzy_System result = null;

            return(result);
        }
Beispiel #22
0
        public static a_Fuzzy_System load_UFS(this a_Fuzzy_System Approx, string file_name)
        {
            a_Fuzzy_System result = Approx;

            Knowlege_base_ARules New_dataBase = new Knowlege_base_ARules();

            List <string> added_term = new List <string>();


            XmlDocument Source = new XmlDocument();

            Source.Load(file_name);

            XmlNode rulles_node = Source.DocumentElement.SelectSingleNode("descendant::Rules");

            if (rulles_node == null)
            {
                throw new System.FormatException("Нет базы правил в ufs файле");
            }
            int     count_rulles  = XmlConvert.ToInt32(rulles_node.Attributes.GetNamedItem("Count").Value);
            XmlNode varibles_node = Source.DocumentElement.SelectSingleNode("descendant::Variables");

            if (varibles_node == null)
            {
                throw new System.FormatException("Нет термов в базе правил, ошибка UFS");
            }
            for (int i = 0; i < count_rulles; i++)
            {
                XmlNode antecedent_node       = rulles_node.ChildNodes[i].SelectSingleNode("Antecedent");
                int     count_antecedent_term = XmlConvert.ToInt32(antecedent_node.Attributes.GetNamedItem("Count").Value);
                int []  Order_term            = new int[count_antecedent_term];
                for (int j = 0; j < count_antecedent_term; j++)
                {
                    double[]            Value_temp;
                    Type_Term_Func_Enum type_term = Type_Term_Func_Enum.Треугольник;
                    int    num_var   = Approx.Learn_Samples_set.Input_Attributes.IndexOf(Approx.Learn_Samples_set.Input_Attributes.Find(x => x.Name.Equals(antecedent_node.ChildNodes[j].Attributes.GetNamedItem("Variable").Value, StringComparison.OrdinalIgnoreCase)));
                    string name_term = antecedent_node.ChildNodes[j].Attributes.GetNamedItem("Term").Value;
                    if (added_term.Contains(name_term))
                    {
                        Order_term[j] = added_term.IndexOf(name_term);
                    }
                    else
                    {
                        XmlNode term_node = varibles_node.SelectSingleNode("descendant::Term[@Name='" + name_term + "']");
                        int     count_MB  = 0;
                        switch (term_node.Attributes.GetNamedItem("Type").Value)
                        {
                        case "Triangle": { count_MB = 3; type_term = Type_Term_Func_Enum.Треугольник; break; }

                        case "Gauss": { count_MB = 2; type_term = Type_Term_Func_Enum.Гауссоида; break; }

                        case "Parabolic": { count_MB = 2; type_term = Type_Term_Func_Enum.Парабола; break; }

                        case "Trapezoid": { count_MB = 4; type_term = Type_Term_Func_Enum.Трапеция; break; }
                        }
                        Value_temp = new double[count_MB];
                        term_node  = term_node.SelectSingleNode("Params");
                        for (int p = 0; p < count_MB; p++)
                        {
                            string tett         = term_node.ChildNodes[p].Attributes.GetNamedItem("Number").Value;
                            int    number_param = XmlConvert.ToInt32(term_node.ChildNodes[p].Attributes.GetNamedItem("Number").Value);
                            Value_temp[number_param] = XmlConvert.ToDouble(term_node.ChildNodes[p].Attributes.GetNamedItem("Value").Value);
                        }

                        Term temp_term = new Term(Value_temp, type_term, num_var);

                        New_dataBase.Terms_Set.Add(temp_term);
                        added_term.Add(name_term);
                        Order_term[j] = New_dataBase.Terms_Set.Count - 1;
                    }
                }

                XmlNode consequnt_node = rulles_node.ChildNodes[i].SelectSingleNode("Consequent");
                double  Approx_value   = XmlConvert.ToDouble(consequnt_node.Attributes.GetNamedItem("Value").Value);

                ARule temp_rule = new ARule(New_dataBase.Terms_Set, Order_term, Approx_value);
                New_dataBase.Rules_Database.Add(temp_rule);
            }
            result.Rulles_Database_Set.Clear();
            result.Rulles_Database_Set.Add(New_dataBase);

            GC.Collect();
            return(result);
        }
Beispiel #23
0
        private static void write_about_table(XmlWriter writer, a_samples_set samplesSet, a_Fuzzy_System Approximate)
        {
            writer.WriteStartElement("Table");
            writer.WriteAttributeString("Name", samplesSet.File_Name);
            if (samplesSet == Approximate.Learn_Samples_set)
            {
                writer.WriteAttributeString("Type", "Training");
            }
            else
            {
                writer.WriteAttributeString("Type", "Testing");
            }
            writer.WriteAttributeString("Output", samplesSet.Output_Attributes.Name);
            writer.WriteStartElement("Attributes");
            writer.WriteAttributeString("Count", XmlConvert.ToString(samplesSet.Count_Vars));
            for (int i = 0; i < samplesSet.Count_Vars; i++)
            {
                write_about_attribute(writer, samplesSet.Input_Attributes[i]);
            }
            write_about_attribute(writer, samplesSet.Output_Attributes);
            writer.WriteEndElement();
            write_about_rows(writer, samplesSet);


            writer.WriteEndElement();
        }
Beispiel #24
0
        public void Calc()
        {
            DateTime   start__full_time = DateTime.Now;
            List <int> gen_index        = prepare_generate_to_Calc();
            List <int> leant_index      = prepare_learn_to_Calc();

            make_Log(Log_line.Start, TimerValue: start__full_time);
            int currentstep = 0;
            int all_step    = (Rules_generator.Count() + Learn_algorithms.Count() * Repeat_into) * Repeat_renew_global;

            currentstep = Make_inform_back_process(currentstep, all_step);

            for (int i = 0; i < Repeat_renew_global; i++)
            {
                Approx_Singletone = new a_Fuzzy_System(Approx_learn_set, Approx_test_set);
                DateTime start__curle_time = DateTime.Now;
                #region Генерация аппроксиматора

                make_Log(Log_line.StartGenerate, TimerValue: start__curle_time);
                for (int ad = 0; ad < Rules_generator.Count(); ad++)
                {
                    make_Log(Log_line.PreGenerate_log, name_Alg: Rules_generator[ad].ToString());
                    Approx_Singletone = Rules_generator[ad].Generate(Approx_Singletone, Rules_generator_conf[gen_index[ad]]);
                    GC.Collect();

                    currentstep = Make_inform_back_process(currentstep, all_step);

                    make_Log(Log_line.PostGenerate_log, Approx_Singletone, name_Alg: Rules_generator[ad].ToString(true));
                    if (is_autosave)
                    {
                        save_FS(Approx_Singletone, Name_alg: Rules_generator[ad].ToString());
                    }
                }

                #endregion

                make_Log(Log_line.StartOptimaze, Approx_Singletone);

                for (int j = 0; j < Repeat_into; j++)
                {
                    #region Оптимизация аппроксиматора
                    for (int l = 0; l < Learn_algorithms.Count(); l++)
                    {
                        make_Log(Log_line.PreOptimaze_log, name_Alg: Learn_algorithms[l].ToString());
                        Approx_Singletone = Learn_algorithms[l].TuneUpFuzzySystem(Approx_Singletone, Learn_algorithm_conf[leant_index [l]]);
                        GC.Collect();

                        currentstep = Make_inform_back_process(currentstep, all_step);

                        make_Log(Log_line.PostOptimaze_log, Approx_Singletone, name_Alg: Learn_algorithms[l].ToString(true));

                        if (is_autosave)
                        {
                            save_FS(Approx_Singletone, Learn_algorithms[l].ToString());
                        }
                    }
                    #endregion
                }
                make_Log(Log_line.EndCircle, TimerSpan: (DateTime.Now - start__curle_time));

                GC.Collect();
            }
            make_Log(Log_line.End, TimerSpan: DateTime.Now - start__full_time);
        }
Beispiel #25
0
        private void make_Log(Log_line EventCall, a_Fuzzy_System FS = null, string name_Alg = "", DateTime TimerValue = new DateTime(), TimeSpan TimerSpan = new TimeSpan())
        {
            switch (EventCall)
            {
            case Log_line.Start:
            {
                LOG += "(" + TimerValue.ToString() + ")" + " Начало построения системы" + Environment.NewLine;
                break;
            }

            case Log_line.StartGenerate:
            {
                LOG += "(" + TimerValue.ToString() + ")" + " Начата генерация системы" + Environment.NewLine;

                break;
            }

            case Log_line.StartOptimaze:
            {
                LOG += "(" + DateTime.Now.ToString() + ")" + " Начата оптимизация системы" + Environment.NewLine;
                break;
            }


            case Log_line.PreGenerate_log:
            {
                LOG += "(" + DateTime.Now.ToString() + ")" + " Генерация алгоритмом " + name_Alg.ToString() + Environment.NewLine;
                break;
            }

            case Log_line.PostGenerate_log:
            {
                LOG += "(" + DateTime.Now.ToString() + ")" + " Сгенерирована система сложностью " + FS.value_complexity().ToString() + Environment.NewLine +
                       "Точностью на обучающей выборке " + FS.approx_Learn_Samples().ToString() + ", Точность на тестовой выборке " + FS.approx_Test_Samples().ToString() + Environment.NewLine;
                LOG += "Использован " + name_Alg.ToString() + Environment.NewLine;
                break;
            }

            case Log_line.PreOptimaze_log:
            {
                LOG += "(" + DateTime.Now.ToString() + ")" + " Оптимизация алгоритмом " + name_Alg.ToString() + Environment.NewLine;

                break;
            }

            case Log_line.PostOptimaze_log:
            {
                LOG += "(" + DateTime.Now.ToString() + ")" + " оптимизированная система сложностью " + FS.value_complexity().ToString() + Environment.NewLine +
                       "Точностью на обучающей выборке " + Approx_Singletone.approx_Learn_Samples().ToString() + ", Точность на тестовой выборке " + FS.approx_Test_Samples().ToString() + Environment.NewLine;
                LOG += "Использован " + name_Alg.ToString() + Environment.NewLine;

                break;
            }


            case Log_line.EndCircle:
            {
                LOG += "(" + DateTime.Now.ToString() + ")" + " Время построения системы" + TimerSpan.TotalSeconds.ToString() + Environment.NewLine; break;
            }

            case Log_line.End:
            {
                LOG += "(" + DateTime.Now.ToString() + ")" + " Время построения всех систем" + TimerSpan.TotalSeconds.ToString() + Environment.NewLine; break;
            }

            default: { LOG += "Не верный вызов" + Environment.NewLine; break; }
            }
        }
Beispiel #26
0
        public override Fuzzy_system.Approx_Singletone.a_Fuzzy_System TuneUpFuzzySystem(Fuzzy_system.Approx_Singletone.a_Fuzzy_System Approximate, Abstract_learn_algorithm_conf conf)
        {
            count_iteration = ((Term_Config_PSO_Search_conf)conf).Количество_итераций;
            c1             = ((Term_Config_PSO_Search_conf)conf).Коэффициент_c1;
            c2             = ((Term_Config_PSO_Search_conf)conf).Коэффициент_c2;
            w              = 1;
            count_particle = ((Term_Config_PSO_Search_conf)conf).Особей_в_популяции;

            a_Fuzzy_System result = Approximate;

            Knowlege_base_ARules[] X  = new Knowlege_base_ARules[count_particle];
            Knowlege_base_ARules[] V  = new Knowlege_base_ARules[count_particle];
            Knowlege_base_ARules[] Pi = new Knowlege_base_ARules[count_particle];
            Knowlege_base_ARules   Pg = new Knowlege_base_ARules();

            double[] Errors    = new double[count_particle];
            double[] OldErrors = new double[count_particle];
            double   minError  = 0;
            Random   rnd       = new Random();

            for (int i = 0; i < count_particle; i++)
            {
                Knowlege_base_ARules temp_c_Rule = new Knowlege_base_ARules(result.Rulles_Database_Set[0]);
                X[i]         = temp_c_Rule;
                Errors[i]    = result.approx_Learn_Samples(0);
                OldErrors[i] = Errors[i];
                Pi[i]        = new Knowlege_base_ARules(X[i]);
                V[i]         = new Knowlege_base_ARules(X[i]);
                //
                for (int j = 0; j < V[i].Terms_Set.Count; j++)
                {
                    for (int k = 0; k < Member_Function.Count_Params_For_Term(V[i].Terms_Set[j].Term_Func_Type); k++)
                    {
                        if (i == 0)
                        {
                            V[i].Terms_Set[j].Parametrs[k] = 0;
                        }
                        else
                        {
                            V[i].Terms_Set[j].Parametrs[k] = rnd.NextDouble() - 0.5;
                        }
                    }
                    double[] bf = new double[V[i].all_conq_of_rules.Length];
                    for (int k = 0; k < V[i].all_conq_of_rules.Length; k++)
                    {
                        if (i == 0)
                        {
                            bf[k] = 1;
                        }
                        else
                        {
                            bf[k] = rnd.NextDouble() / 200;
                        }
                    }
                    V[i].all_conq_of_rules = bf;
                }
            }
            Pg       = new Knowlege_base_ARules(result.Rulles_Database_Set[0]);
            minError = Errors[0];
            for (int i = 0; i < count_iteration; i++)
            {
                for (int j = 0; j < count_particle; j++)
                {
                    w = 1 / (1 + Math.Exp(-(Errors[j] - OldErrors[j]) / 0.01));
                    for (int k = 0; k < X[j].Terms_Set.Count; k++)
                    {
                        for (int q = 0; q < Member_Function.Count_Params_For_Term(X[j].Terms_Set[k].Term_Func_Type); q++)
                        {
                            double bp = Pi[j].Terms_Set[k].Parametrs[q];
                            V[j].Terms_Set[k].Parametrs[q] = V[j].Terms_Set[k].Parametrs[q] * w + c1 * rnd.NextDouble() * (bp - X[j].Terms_Set[k].Parametrs[q]) +
                                                             c2 * rnd.NextDouble() * (Pg.Terms_Set[k].Parametrs[q] - X[j].Terms_Set[k].Parametrs[q]);
                            X[j].Terms_Set[k].Parametrs[q] += V[j].Terms_Set[k].Parametrs[q];
                        }
                    }
                    double[] bf  = new double[V[j].all_conq_of_rules.Length];
                    double[] bfw = new double[V[j].all_conq_of_rules.Length];
                    for (int k = 0; k < V[j].all_conq_of_rules.Length; k++)
                    {
                        bfw[k] = V[j].all_conq_of_rules[k] * w + c1 * rnd.NextDouble() * (Pi[j].all_conq_of_rules[k] - X[j].all_conq_of_rules[k]) +
                                 c2 * rnd.NextDouble() * (Pg.all_conq_of_rules[k] - X[j].all_conq_of_rules[k]);
                        double sw = X[j].all_conq_of_rules[k] + bfw[k];
                        if (sw > 0 && sw <= 2)
                        {
                            bf[k] = sw;
                        }
                        else
                        {
                            bf[k]  = X[j].all_conq_of_rules[k];
                            bfw[k] = V[j].all_conq_of_rules[k];
                        }
                    }
                    X[j].all_conq_of_rules = bf;
                    V[j].all_conq_of_rules = bfw;
                    double newError = 0;
                    result.Rulles_Database_Set.Add(X[j]);
                    int  temp_index = result.Rulles_Database_Set.Count - 1;
                    bool success    = true;
                    try
                    {
                        newError = result.approx_Learn_Samples(temp_index);
                    }
                    catch (Exception)
                    {
                        success = false;
                    }
                    result.Rulles_Database_Set.RemoveAt(temp_index);
                    if (success && (newError > Errors[j]))
                    {
                        OldErrors[j] = Errors[j];
                        Errors[j]    = newError;

                        Pi[j] = new Knowlege_base_ARules(X[j]);
                    }
                    if (minError < newError)
                    {
                        minError = newError;
                        Pg       = new Knowlege_base_ARules(X[j]);
                    }
                }
            }
            result.Rulles_Database_Set[0] = Pg;
            GC.Collect();
            return(result);
        }
Beispiel #27
0
 public abstract a_Fuzzy_System TuneUpFuzzySystem(a_Fuzzy_System Approximate, Abstract_learn_algorithm_conf conf);