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 void init_first(Knowlege_base_ARules base_rule, Random rand, Individ.Type_init prm_init)
{
bool the_first = true;
int count_ready = 0;
do
{
the_popualate.Add(new Individ(base_rule, Data, count_vars, the_first, rand, prm_init));
count_ready++;
the_first = false;
} while (count_ready < size_populate);
}
private double[, ,] extract_Rules(Knowlege_base_ARules rules_Database)
{
int count_rules = rules_Database.Rules_Database.Count;
int count_vars = rules_Database.Rules_Database[0].Term_of_Rule_Set.Count;
int count_term_params = Member_Function.Count_Params_For_Term(rules_Database.Terms_Set[0].Term_Func_Type);
double [,,] Result = new double[count_rules, count_vars, count_term_params];
for (int i = 0; i < count_rules; i++)
{
for (int j = 0; j < count_vars; j++)
{
Term temp_term = rules_Database.Rules_Database[i].Term_of_Rule_Set.First(x => x.Number_of_Input_Var == j);
for (int k = 0; k < count_term_params; k++)
{
Result[i, j, k] = temp_term.Parametrs[k];
}
}
}
return(Result);
}
public Individ(Knowlege_base_ARules Source, a_samples_set data, int count_vars, bool the_first, Random rand, Type_init par_type_init)
{
hrom_vector = new Hromosom(new Knowlege_base_ARules(Source));
step_sko = new List <double>(count_vars);
step_rotate = new List <double>(count_vars);
count_step_sko = count_vars;
count_step_rotate = count_vars;
Data = data;
for (int i = 0; i < count_vars; i++)
{
step_sko.Add(0 + rand.NextDouble() * (data.Attribute_Scatter(i) * 0.05));
step_rotate.Add(-1 * Math.PI + rand.NextDouble() * 2 * Math.PI);
}
if (!the_first)
{
switch (par_type_init)
{
case Type_init.Случайная: hrom_vector.init_random(rand, data); break;
case Type_init.Ограниченная: hrom_vector.init_constrain(rand, data); break;
}
}
}
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);
}
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 Hromosom(Hromosom the_Source)
{
core_check = new Knowlege_base_ARules(the_Source.core_check);
Fenotip_kons = core_check.all_conq_of_rules.ToList();
Fenotip_terms = core_check.Terms_Set;
}
public Hromosom(Knowlege_base_ARules Source)
{
core_check = Source;
Fenotip_kons = core_check.all_conq_of_rules.ToList();
Fenotip_terms = core_check.Terms_Set;
}
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);
}
