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);
}
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);
}
public init_everyone_with_everyone(int count_vars)
{
type_term_func = (Type_Term_Func_Enum)Settings.Default.init_everyone_with_everyone_func;
count_terms = new int[count_vars];
for (int i = 0; i < count_vars; i++)
{
count_terms[i] = Settings.Default.init_everyone_with_everyone_agv_count_terms;
}
Количество_термов_для_каждого_признака = count_terms;
}
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 void Init_Rules_By_samples(Type_Term_Func_Enum type_func)
{
if (Count_Rulles_Databases == 0)
{
Knowlege_base_CRules temp_rules = new Knowlege_base_CRules();
rulles_database_set.Add(temp_rules);
}
for (int i = 0; i < Count_Class; i++)
{
if (!learn_samples_set.exist_class_var_max(i) || !learn_samples_set.exist_class_var_min(i))
{
continue;
}
int[] order_terms = new int[Count_Vars];
for (int j = 0; j < Count_Vars; j++)
{
double[] paramerts = new double[c_Fuzzy_System.Count_Params_For_Term(type_func)];
switch (type_func)
{
case Type_Term_Func_Enum.Треугольник:
paramerts[0] = learn_samples_set.get_class_var_min(i, j) - 0.001 * (learn_samples_set.get_class_var_max(i, j) - learn_samples_set.get_class_var_min(i, j));
paramerts[2] = learn_samples_set.get_class_var_max(i, j) + 0.001 * (learn_samples_set.get_class_var_max(i, j) - learn_samples_set.get_class_var_min(i, j));
paramerts[1] = (paramerts[0] + paramerts[2]) / 2;
break;
case Type_Term_Func_Enum.Гауссоида:
paramerts[0] = (learn_samples_set.get_class_var_max(i, j) +
learn_samples_set.get_class_var_min(i, j)) / 2;
paramerts[1] = (paramerts[0] - learn_samples_set.get_class_var_min(i, j)) / 3; // rule of 3g
break;
case Type_Term_Func_Enum.Парабола:
paramerts[0] = learn_samples_set.get_class_var_min(i, j) - 0.001 * (learn_samples_set.get_class_var_max(i, j) - learn_samples_set.get_class_var_min(i, j));
paramerts[1] = learn_samples_set.get_class_var_max(i, j) + 0.001 * (learn_samples_set.get_class_var_max(i, j) - learn_samples_set.get_class_var_min(i, j));
break;
case Type_Term_Func_Enum.Трапеция:
paramerts[0] = learn_samples_set.get_class_var_min(i, j) - 0.001 * (learn_samples_set.get_class_var_max(i, j) - learn_samples_set.get_class_var_min(i, j));
paramerts[3] = learn_samples_set.get_class_var_max(i, j) + 0.001 * (learn_samples_set.get_class_var_max(i, j) - learn_samples_set.get_class_var_min(i, j));
paramerts[1] = paramerts[0] + 0.4 * (paramerts[3] - paramerts[0]);
paramerts[2] = paramerts[0] + 0.6 * (paramerts[3] - paramerts[0]);
break;
}
Term temp_term = new Term(paramerts, type_func, j);
rulles_database_set[0].Terms_Set.Add(temp_term);
order_terms[j] = rulles_database_set[0].Terms_Set.Count - 1;
}
CRule temp_Rule = new CRule(rulles_database_set[0].Terms_Set, order_terms,
learn_samples_set.Output_Attributes.labels_values[i], 1);
rulles_database_set[0].Rules_Database.Add(temp_Rule);
}
}
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);
}
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);
}
public static string ToString(Type_Term_Func_Enum tf)
{
switch (tf)
{
case Type_Term_Func_Enum.Гауссоида: return("Гауссоида");
case Type_Term_Func_Enum.Парабола: return("Парабола");
case Type_Term_Func_Enum.Трапеция: return("Трапеция");
case Type_Term_Func_Enum.Треугольник: return("Треугольник");
}
return("Треугольная");
}
public static int Count_Params_For_Term(Type_Term_Func_Enum type_term)
{
switch (type_term)
{
case Type_Term_Func_Enum.Треугольник:
return(3);
case Type_Term_Func_Enum.Гауссоида:
return(2);
case Type_Term_Func_Enum.Парабола:
return(2);
case Type_Term_Func_Enum.Трапеция:
return(4);
}
return(0);
}
public Term(double[] paramtrs, Type_Term_Func_Enum type_term, int num_var)
{
parametrs = paramtrs;
term_tunc_type = type_term;
number_of_input_var = num_var;
}
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);
}
public void Init_Rules_everyone_with_everyone(Type_Term_Func_Enum type_func, int[] count_slice__for_var)
{
if (Count_Rulles_Databases == 0)
{
Knowlege_base_ARules temp_rules = new Knowlege_base_ARules();
rulles_database_set.Add(temp_rules);
}
int[][] position_of_terms = new int[Count_Vars][];
for (int i = 0; i < Count_Vars; i++)
{
position_of_terms[i] = new int[count_slice__for_var[i]];
double current_value = learn_samples_set.Attribute_Min(i);
double coeef = (learn_samples_set.Attribute_Scatter(i)) /
(count_slice__for_var[i] - 1);
for (int j = 0; j < count_slice__for_var[i]; j++)
{
double[] parametrs = new double[Member_Function.Count_Params_For_Term(type_func)];
switch (type_func)
{
case Type_Term_Func_Enum.Треугольник:
parametrs[1] = current_value;
parametrs[0] = parametrs[1] - coeef;
parametrs[2] = parametrs[1] + coeef;
break;
case Type_Term_Func_Enum.Гауссоида:
parametrs[0] = current_value;
parametrs[1] = coeef / 3;
break;
case Type_Term_Func_Enum.Парабола:
parametrs[0] = current_value - coeef;
parametrs[1] = current_value + coeef;
break;
case Type_Term_Func_Enum.Трапеция:
parametrs[0] = current_value - coeef;
parametrs[3] = current_value + coeef;
parametrs[1] = parametrs[0] + 0.4 * (parametrs[3] - parametrs[0]);
parametrs[2] = parametrs[0] + 0.6 * (parametrs[3] - parametrs[0]);
break;
}
Term temp_term = new Term(parametrs, type_func, i);
rulles_database_set[0].Terms_Set.Add(temp_term);
position_of_terms[i][j] = rulles_database_set[0].Terms_Set.Count - 1;
current_value += coeef;
}
}
int[] counter = new int[Count_Vars];
for (int i = 0; i < Count_Vars; i++)
{
counter[i] = count_slice__for_var[i] - 1;
}
while (counter[0] >= 0)
{
List <Term> temp_term_set = new List <Term>();
int[] order = new int[Count_Vars];
for (int i = 0; i < Count_Vars; i++)
{
temp_term_set.Add(rulles_database_set[0].Terms_Set[position_of_terms[i][counter[i]]]);
order[i] = position_of_terms[i][counter[i]];
}
double approx_Values = Nearest_Approx(temp_term_set);
ARule temp_rule = new ARule(rulles_database_set[0].Terms_Set, order, approx_Values);
rulles_database_set[0].Rules_Database.Add(temp_rule);
counter = dec_count(counter, count_slice__for_var);
}
} //Core init method
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);
}
public static double[] generate_params_for_term(double Center, double distance, Type_Term_Func_Enum type_func)
{
double[] result = new double[Member_Function.Count_Params_For_Term(type_func)];
switch (type_func)
{
case Type_Term_Func_Enum.Гауссоида:
{
result[0] = Center;
result[1] = distance / 3;
} break;
case Type_Term_Func_Enum.Треугольник:
{
result[0] = Center - distance;
result[1] = Center;
result[2] = Center + distance;
} break;
case Type_Term_Func_Enum.Парабола:
{
result[0] = Center - distance;
result[1] = Center + distance;
} break;
case Type_Term_Func_Enum.Трапеция:
{
result[0] = Center - distance;
result[3] = Center + distance;
result[1] = result[0] + 0.8 * distance;
result[2] = result[0] + 1.2 * distance;
} break;
}
return(result);
}
public static Term Make_Term(double center, double distance, Type_Term_Func_Enum type_func, int number_of_input_var)
{
Term Result = new Term(generate_params_for_term(center, distance, type_func), type_func, number_of_input_var);
return(Result);
}
public init_by_samples_conf()
{
type_term_func = (Type_Term_Func_Enum)Settings.Default.init_by_samples_conf_Type_func;
}
public override c_Fuzzy_System Generate(Fuzzy_system.Class_Pittsburgh.c_Fuzzy_System Classifier, Abstract_generator_conf config)
{
Random rand = new Random();
c_Fuzzy_System result = Classifier;
if (result.Count_Rulles_Databases == 0)
{
Knowlege_base_CRules temp_rules = new Knowlege_base_CRules();
result.Rulles_Database_Set.Add(temp_rules);
}
Type_Term_Func_Enum type_term = ((Generator_Rulles_simple_random_conf)config).Функция_принадлежности;
int stable_terms = (int)((Generator_Rulles_simple_random_conf)config).Тип_Термов;
int 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[c_Fuzzy_System.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;
}
string class_label = result.Nearest_Class(temp_term_list);
CRule temp_Rule = new CRule(result.Rulles_Database_Set[0].Terms_Set, order, class_label, 1.0);
result.Rulles_Database_Set[0].Rules_Database.Add(temp_Rule);
}
result.unlaid_protection_fix();
return(result);
}
public Term(Term source)
{
parametrs = (double[])source.parametrs.Clone();
term_tunc_type = ((Type_Term_Func_Enum)((int)source.Term_Func_Type));
number_of_input_var = source.number_of_input_var;
}
