public double approx_base(double[] object_c, int num_vector = 0)
{
List <ARule> temp_all_rules_for_chosen_approx =
rulles_database_set[num_vector].Rules_Database;
double sum = 0;
double sum2 = 0;
for (int k = 0; k < temp_all_rules_for_chosen_approx.Count; k++)
{
double mul = 1;
for (int q = 0; q < temp_all_rules_for_chosen_approx[k].Term_of_Rule_Set.Count; q++)
{
double[] par;
mul *= Member_Function.Func((int)temp_all_rules_for_chosen_approx[k].Term_of_Rule_Set[q].Term_Func_Type, temp_all_rules_for_chosen_approx[k].Term_of_Rule_Set[q].Parametrs
, object_c[temp_all_rules_for_chosen_approx[k].Term_of_Rule_Set[q].Number_of_Input_Var], out par);
if (mul == 0)
{
break;
}
}
sum2 += mul;
sum += mul * temp_all_rules_for_chosen_approx[k].Kons_approx_Value;
}
if (sum2 != 0)
{
return(sum / sum2);
}
return(double.MaxValue);
}
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 override string ToString(bool with_param = false)
{
if (with_param)
{
string result = "модификация k-средних {";
result += "Тип модификции = ";
switch (this.type_alg)
{
case Type_k_mean_algorithm.FCM: result += "FCM"; break;
case Type_k_mean_algorithm.Gath_geva: result += "Gath-Geva"; break;
case Type_k_mean_algorithm.Gustafson_Kessel: result += "Guthstafson Kessel"; break;
}
result += " ; " + Environment.NewLine;
result += "Функции принадлежности= " + Member_Function.ToString(type_func) + " ;" + Environment.NewLine;
result += "Генерируется правил= " + this.count_rules.ToString() + " ;" + Environment.NewLine;
result += "Итераций = " + this.Max_iteration.ToString() + " ;" + Environment.NewLine;
result += "Экспоненциальный вес = " + this.nebulisation_factor.ToString() + " ;" + Environment.NewLine;
result += "}";
return(result);
}
return("модификация k-средних");
}
private Term randomize_term(Term source)
{
Term result = source;
for (int k = 0; k < Member_Function.Count_Params_For_Term(source.Term_Func_Type); k++)
{
result.Parametrs[k] = GaussRandom.Random_gaussian(rand, result.Parametrs[k], result.Parametrs[k] / 10);
}
return(result);
}
public override string ToString(bool with_param = false)
{
if (with_param)
{
string result = "перебор с равномерным разбиением {";
result += "Функции принадлежности= " + Member_Function.ToString(type_func) + " ;" + Environment.NewLine;
for (int i = 0; i < count_slice_vars.Count(); i++)
{
result += " " + count_slice_vars[i].ToString() + " " + pluralform.nobot(count_slice_vars[i], new string[3] {
"терм", "терма", "термов"
}) + " по " + (i + 1).ToString() + " " + " параметру ;" + Environment.NewLine;
}
result += "}";
return(result);
}
return("перебор с равномерным разбиением");
}
public override string ToString(bool with_param = false)
{
if (with_param)
{
string result = "отсечение правил {";
result += "Функции принадлежности= " + Member_Function.ToString(type_term) + " ;" + Environment.NewLine;
result += "Требуется правил =" + Request_count_rules.ToString() + " ; " + Environment.NewLine;
for (int i = 0; i < count_slices.Count(); i++)
{
result += " " + count_slices[i].ToString() + pluralform.nobot(count_slices[i], new string[3] {
"терм", "терма", "термов"
}) + " по " + (i + 1).ToString() + " " + " параметру ;" + Environment.NewLine;
}
result += "}";
return(result);
}
return(" отсечение правил");
}
public string classify_base(double[] object_c, int num_vector = 0)
{
int index_class = 0;
double max_sum = 0;
bool correct_classificate = false;
for (int j = 0; j < Count_Class; j++)
{
List <
CRule> temp_all_rules_for_chosen_class =
rulles_database_set[num_vector].Rules_Database.FindAll(
x => x.Label_of_Class == learn_samples_set.Output_Attributes.labels_values[j]);
double sum = 0;
for (int k = 0; k < temp_all_rules_for_chosen_class.Count; k++)
{
double mul = 1;
for (int q = 0; q < temp_all_rules_for_chosen_class[k].Term_of_Rule_Set.Count; q++)
{
double[] par;
mul *= Member_Function.Func((int)temp_all_rules_for_chosen_class[k].Term_of_Rule_Set[q].Term_Func_Type, temp_all_rules_for_chosen_class[k].Term_of_Rule_Set[q].Parametrs
, object_c[temp_all_rules_for_chosen_class[k].Term_of_Rule_Set[q].Number_of_Input_Var], out par);
if (mul == 0)
{
break;
}
}
sum += mul * temp_all_rules_for_chosen_class[k].CF;
}
if (max_sum < sum)
{
correct_classificate = true;
max_sum = sum;
index_class = j;
}
}
if (!correct_classificate)
{
return("nonResult");
//throw (new ArgumentException(
// "Невозможно классифицировать объект скорее всего существуют не накрытые участи на признаках"));
}
return(learn_samples_set.Output_Attributes.labels_values[index_class]);
}
public override string ToString(bool with_param = false)
{
if (with_param)
{
string result = "отсечение правил {";
result += "Функции принадлежности= " + Member_Function.ToString(type_func) + " ;" + Environment.NewLine;
result += "По скольким параметрам уменшать =" + this.count_shrink.ToString() + " ; " + Environment.NewLine;
result += "На сколько уменьшать термов =" + this.size_shrink.ToString() + " ; " + Environment.NewLine;
for (int i = 0; i < count_slices.Count(); i++)
{
result += " " + count_slices[i].ToString() + pluralform.nobot(count_slices[i], new string[3] {
"терм", "терма", "термов"
}) + " по " + (i + 1).ToString() + " " + " параметру ;" + Environment.NewLine;
}
result += "}";
return(result);
}
return("отсечение правил");
}
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();
}
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 override string ToString(bool with_param = false)
{
if (with_param)
{
string result = "случайная генерация {";
result += "Функции принадлежности= " + Member_Function.ToString(type_term) + " ;" + Environment.NewLine;
result += "Генерируется правил =" + this.count_rules.ToString() + " ; " + Environment.NewLine;
result += "Генерация правил случайной функции принадлежности =";
if (stable_terms == 0)
{
result += "Нет";
}
else
{
result += "Да";
}
result += " ; " + Environment.NewLine;
result += "}";
return(result);
}
return("случайная генерация");
}
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 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 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);
}
