protected void InitRulesBySamples(PCFuzzySystem Classifier, TypeTermFuncEnum typeFunc)
{
if ((Classifier.RulesDatabaseSet == null) || (Classifier.RulesDatabaseSet.Count == 0))
{
KnowlegeBasePCRules temp_rules = new KnowlegeBasePCRules();
Classifier.RulesDatabaseSet.Add(temp_rules);
}
for (int i = 0; i < Classifier.CountClass; i++)
{
if (!ExistClassFeatureMax(i) || !ExistClassFeatureMin(i))
{
continue;
}
int[] order_terms = new int[Classifier.CountFeatures];
for (int j = 0; j < Classifier.CountFeatures; j++)
{
if (Classifier.AcceptedFeatures[j] == false)
{
continue;
}
double[] paramerts = new double[Term.CountParamsinSelectedTermType(typeFunc)];
switch (typeFunc)
{
case TypeTermFuncEnum.Треугольник:
paramerts[0] = min_for_class[i][j] - 0.001 * (max_for_class[i][j] - min_for_class[i][j]);
paramerts[2] = max_for_class[i][j] + 0.001 * (max_for_class[i][j] - min_for_class[i][j]);
paramerts[1] = (paramerts[0] + paramerts[2]) / 2;
break;
case TypeTermFuncEnum.Гауссоида:
paramerts[0] = (max_for_class[i][j] +
min_for_class[i][j]) / 2;
paramerts[1] = (paramerts[0] - min_for_class[i][j]) / 3; // rule of 3g
break;
case TypeTermFuncEnum.Парабола:
paramerts[0] = min_for_class[i][j] - 0.001 * (max_for_class[i][j] - min_for_class[i][j]);
paramerts[1] = max_for_class[i][j] + 0.001 * (max_for_class[i][j] - min_for_class[i][j]);
break;
case TypeTermFuncEnum.Трапеция:
paramerts[0] = min_for_class[i][j] - 0.001 * (max_for_class[i][j] - min_for_class[i][j]);
paramerts[3] = max_for_class[i][j] + 0.001 * (max_for_class[i][j] - min_for_class[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, typeFunc, j);
Classifier.RulesDatabaseSet[0].TermsSet.Add(temp_term);
order_terms[j] = Classifier.RulesDatabaseSet[0].TermsSet.Count - 1;
}
PCRule temp_Rule = new PCRule(Classifier.RulesDatabaseSet[0].TermsSet, order_terms,
Classifier.LearnSamplesSet.OutputAttribute.LabelsValues[i], 1);
Classifier.RulesDatabaseSet[0].RulesDatabase.Add(temp_Rule);
}
}
public static void InitRulesEveryoneWithEveryone(PCFuzzySystem Classifier, TypeTermFuncEnum typeFunc, int[] countSliceForVar)
{
if ((Classifier.RulesDatabaseSet == null) || (Classifier.RulesDatabaseSet.Count == 0))
{
KnowlegeBasePCRules temp_rules = new KnowlegeBasePCRules();
Classifier.RulesDatabaseSet.Add(temp_rules);
}
int[][] position_of_terms = new int[Classifier.CountFeatures][];
for (int i = 0; i < Classifier.CountFeatures; i++)
{
position_of_terms[i] = new int[countSliceForVar[i]];
double current_value = Classifier.LearnSamplesSet.InputAttributes[i].Min;
double coeef = (Classifier.LearnSamplesSet.InputAttributes[i].Scatter);
if (countSliceForVar[i] > 1)
{
coeef = coeef / (countSliceForVar[i] - 1);
}
if (countSliceForVar[i] == 1)
{
current_value = current_value + coeef * 0.5;
coeef *= 1.000000001 / 2;
}
for (int j = 0; j < countSliceForVar[i]; j++)
{
double[] parametrs = new double[Term.CountParamsinSelectedTermType(typeFunc)];
switch (typeFunc)
{
case TypeTermFuncEnum.Треугольник:
parametrs[1] = current_value;
parametrs[0] = parametrs[1] - coeef;
parametrs[2] = parametrs[1] + coeef;
break;
case TypeTermFuncEnum.Гауссоида:
parametrs[0] = current_value;
parametrs[1] = coeef / 3;
break;
case TypeTermFuncEnum.Парабола:
parametrs[0] = current_value - coeef;
parametrs[1] = current_value + coeef;
break;
case TypeTermFuncEnum.Трапеция:
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, typeFunc, i);
if (countSliceForVar[i] > 1)
{
if ((j == 0) && (typeFunc != TypeTermFuncEnum.Гауссоида))
{
temp_term.Min -= 0.00000001 * (temp_term.Max - temp_term.Min);
}
if ((j == countSliceForVar[i] - 1) && (typeFunc != TypeTermFuncEnum.Гауссоида))
{
temp_term.Max += 0.0000001 * (temp_term.Max - temp_term.Min);
}
}
Classifier.RulesDatabaseSet[0].TermsSet.Add(temp_term);
position_of_terms[i][j] = Classifier.RulesDatabaseSet[0].TermsSet.Count - 1;
current_value += coeef;
}
}
int first_notNull = -1;
int[] counter = new int[Classifier.CountFeatures];
for (int i = 0; i < Classifier.CountFeatures; i++)
{
if (Classifier.AcceptedFeatures[i] == false)
{
continue;
}
counter[i] = countSliceForVar[i] - 1;
if ((counter[i] != -1) && first_notNull == -1)
{
first_notNull = i;
}
}
while (counter[first_notNull] >= 0 && counter[0] >= -1)
{
List <Term> temp_term_set = new List <Term>();
int[] order = new int[Classifier.CountFeatures];
for (int i = 0; i < Classifier.CountFeatures; i++)
{
if ((counter[i] == -1) || (Classifier.AcceptedFeatures[i] == false))
{
order[i] = -1;
continue;
}
temp_term_set.Add(Classifier.RulesDatabaseSet[0].TermsSet[position_of_terms[i][counter[i]]]);
order[i] = position_of_terms[i][counter[i]];
}
string class_label = KNNClassName.NearestClass(Classifier, temp_term_set);
PCRule temp_rule = new PCRule(Classifier.RulesDatabaseSet[0].TermsSet, order, class_label, 1.0);
Classifier.RulesDatabaseSet[0].RulesDatabase.Add(temp_rule);
counter = dec_count(counter, countSliceForVar, Classifier.CountFeatures);
}
}
public override PCFuzzySystem Generate(FuzzySystem.PittsburghClassifier.PCFuzzySystem Classifier, IGeneratorConf config)
{
Random rand = new Random();
PCFuzzySystem result = Classifier;
if (result.RulesDatabaseSet.Count == 0)
{
KnowlegeBasePCRules temp_rules = new KnowlegeBasePCRules();
result.RulesDatabaseSet.Add(temp_rules);
}
type_term = ((GeneratorRullesSimpleRandomConfig)config).RSRTypeFunc;
stable_terms = (int)((GeneratorRullesSimpleRandomConfig)config).RSRConstant;
count_rules = ((GeneratorRullesSimpleRandomConfig)config).RSRCountRules;
for (int j = 0; j < count_rules; j++)
{
int[] order = new int[result.CountFeatures];
TypeTermFuncEnum 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.CountFeatures; k++)
{
double[] parametrs = new double[Term.CountParamsinSelectedTermType(temp_type_term)];
switch (temp_type_term)
{
case TypeTermFuncEnum.Треугольник:
parametrs[0] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
parametrs[1] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
parametrs[2] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
Array.Sort(parametrs);
break;
case TypeTermFuncEnum.Гауссоида: parametrs[0] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
parametrs[1] = (rand.NextDouble() + 0.01) * 0.5 *
(result.LearnSamplesSet.InputAttributes[k].Max -
result.LearnSamplesSet.InputAttributes[k].Min);
break;
case TypeTermFuncEnum.Парабола: parametrs[0] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
parametrs[1] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
Array.Sort(parametrs);
break;
case TypeTermFuncEnum.Трапеция: parametrs[0] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
parametrs[1] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
parametrs[2] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
parametrs[3] = result.LearnSamplesSet.InputAttributes[k].Min + rand.NextDouble() * (result.LearnSamplesSet.InputAttributes[k].Max - result.LearnSamplesSet.InputAttributes[k].Min);
Array.Sort(parametrs);
break;
}
Term temp_term = new Term(parametrs, temp_type_term, k);
result.RulesDatabaseSet[0].TermsSet.Add(temp_term);
temp_term_list.Add(temp_term);
order[k] = result.RulesDatabaseSet[0].TermsSet.Count - 1;
}
string class_label = KNNClassName.NearestClass(result, temp_term_list);
PCRule temp_Rule = new PCRule(result.RulesDatabaseSet[0].TermsSet, order, class_label, 1.0);
result.RulesDatabaseSet[0].RulesDatabase.Add(temp_Rule);
}
result.UnlaidProtectionFix(result.RulesDatabaseSet[0]);
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Approximate, ILearnAlgorithmConf conf) // + override
{
result = Approximate;
List <KnowlegeBasePCRules> Archive = new List <KnowlegeBasePCRules>();
List <double> ErrorsArchive = new List <double>();
var config = (DynamicTuneConf)conf;
maxError = config.MaxError;
RuleCount = config.RulesCount;
TryCount = config.TryCount;
double error = result.ErrorLearnSamples(result.RulesDatabaseSet[0]);
var kbToOptimize = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]);
var kbBest = new KnowlegeBasePCRules(kbToOptimize);
double errorBefore = Double.MaxValue;
result.UnlaidProtectionFix(kbToOptimize);
List <input_space> variable_spaces = new List <input_space>();
for (int i = 0; i < result.LearnSamplesSet.InputAttributes.Count; i++)
{
List <Term> terms_of_variable = new List <Term>();
terms_of_variable = kbToOptimize.TermsSet.Where(term => term.NumVar == i).ToList();
variable_spaces.Add(new input_space(terms_of_variable, i));
}
int indexRegion = -1,
indexVar = -1,
number_of_input_variables = variable_spaces.Count;
int tryCount = 0;
while (error > maxError)
{
if (Double.IsInfinity(error))
{
throw new Exception("Something went wrong, error is Infinity, region: " + indexRegion);
}
if (Double.IsNaN(error))
{
throw new Exception("Something went wrong, error is NaN, region: " + indexRegion);
}
region_side[][] sides = new region_side[number_of_input_variables][];
for (int i = 0; i < number_of_input_variables; i++)
{
sides[i] = variable_spaces[i].get_region_sides();
}
var cartresult = CartesianProduct.Get(sides);
List <region2> regions = new List <region2>();
foreach (var x in cartresult)
{
regions.Add(new region2(x.ToList(), result, variable_spaces));
}
List <double> region_errors = regions.Select(x => x.region_error()).ToList();
indexRegion = region_errors.IndexOf(region_errors.Max());
for (int i = 0; i < region_errors.Count; i++)
{
if (Double.IsNaN(region_errors[i]) || Double.IsInfinity(region_errors[i]) ||
Double.IsNegativeInfinity(region_errors[i]) || Double.IsPositiveInfinity(region_errors[i]))
{
region_errors[i] = 0;
}
}
List <double> variable_errors = regions[indexRegion].variable_errors();
bool check1 = false;
for (int i = 1; i < variable_errors.Count; i++)
{
if (variable_errors[i - 1] != variable_errors[i])
{
check1 = true;
break;
}
}
if (!check1)
{
indexVar = StaticRandom.Next(variable_errors.Count - 1);
}
else
{
indexVar = variable_errors.IndexOf(variable_errors.Max());
}
Term new_term = regions[indexRegion].new_term(indexVar);
result.RulesDatabaseSet[0] = kbToOptimize;
kbToOptimize.TermsSet.Add(new_term);
// Rules (CHECK REFERENCE TYPES)
int @var = indexVar;
var rulesLeft = kbToOptimize.RulesDatabase.Where(
rule => rule.ListTermsInRule.Contains(regions[indexRegion].sides[indexVar].left)).ToList();
var rulesRight = kbToOptimize.RulesDatabase.Where(
rule => rule.ListTermsInRule.Contains(regions[indexRegion].sides[indexVar].right)).ToList();
for (int j = 0; j < rulesLeft.Count; j++)
{
int[] order = new int[rulesLeft[j].ListTermsInRule.Count];
for (int k = 0; k < rulesLeft[j].ListTermsInRule.Count; k++)
{
Term temp_term = rulesLeft[j].ListTermsInRule[k];
if (temp_term == regions[indexRegion].sides[indexVar].left)
{
temp_term = new_term;
}
order[k] = kbToOptimize.TermsSet.FindIndex(x => x == temp_term);
}
///!!!!
string temp_approx_Values = kbToOptimize.RulesDatabase[j].LabelOfClass;
/* double[] temp_approx_RegressionConstantConsequent =
* kbToOptimize.RulesDatabase[j].RegressionConstantConsequent.Clone() as double[];
*/
PCRule temp_rule = new PCRule(
kbToOptimize.TermsSet, order, temp_approx_Values);
// double[] dC = null;
//!!!
temp_rule.LabelOfClass = KNNClassName.NearestClass(result, temp_rule.ListTermsInRule.ToList());
kbToOptimize.RulesDatabase.Add(temp_rule);
//!!!
rulesLeft[j].LabelOfClass = KNNClassName.NearestClass(result, rulesLeft[j].ListTermsInRule.ToList());
// rulesLeft[j].RegressionConstantConsequent = (double[])dC.Clone();
}
foreach (var rule in rulesRight)
{
//!!!
rule.LabelOfClass = KNNClassName.NearestClass(
result, rule.ListTermsInRule.ToList());
// rule.RegressionConstantConsequent = dC;
}
variable_spaces[indexVar].terms.Add(new_term);
variable_spaces[indexVar].terms.Sort(new CompararerByPick());
// Re-evaluate the system's error
//!!!!
error = result.ErrorLearnSamples(kbToOptimize);
if ((kbToOptimize.RulesDatabase.Count > config.RulesCount))
{
break;
}
#if Console
Console.WriteLine(error + " " + kbToOptimize.TermsSet.Count + " terms\n");
for (int i = 0; i < variable_spaces.Count; i++)
{
Console.WriteLine(variable_spaces[i].terms.Count + " термов по " + i + "му параметру\n");
}
#endif
result.RulesDatabaseSet[0] = kbToOptimize;
// Get the best knowledge base on the 1st place
if (error < errorBefore)
{
kbBest = new KnowlegeBasePCRules(kbToOptimize);
errorBefore = error;
tryCount = 0;
}
else
{
tryCount++;
}
if (tryCount > TryCount)
{
break;
}
}
result.RulesDatabaseSet[0] = kbBest;
RuleCount = kbBest.RulesDatabase.Count;
TryCount = tryCount;
return(result);
}
public static PCFuzzySystem loadUFS(this PCFuzzySystem Classifier, XmlDocument Source)
{
PCFuzzySystem result = Classifier;
KnowlegeBasePCRules New_dataBase = new KnowlegeBasePCRules();
List <string> added_term = new List <string>();
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;
TypeTermFuncEnum type_term = TypeTermFuncEnum.Треугольник;
int num_var = Classifier.LearnSamplesSet.InputAttributes.IndexOf(Classifier.LearnSamplesSet.InputAttributes.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 = TypeTermFuncEnum.Треугольник; break; }
case "Gauss": { count_MB = 2; type_term = TypeTermFuncEnum.Гауссоида; break; }
case "Parabolic": { count_MB = 2; type_term = TypeTermFuncEnum.Парабола; break; }
case "Trapezoid": { count_MB = 4; type_term = TypeTermFuncEnum.Трапеция; 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.TermsSet.Add(temp_term);
added_term.Add(name_term);
Order_term[j] = New_dataBase.TermsSet.Count - 1;
}
}
XmlNode consequnt_node = rulles_node.ChildNodes[i].SelectSingleNode("Consequent");
string Classifier_value = consequnt_node.Attributes.GetNamedItem("Class").Value;
double Classifier_Weigths = XmlConvert.ToDouble(consequnt_node.Attributes.GetNamedItem("CF").Value);
PCRule temp_rule = new PCRule(New_dataBase.TermsSet, Order_term, Classifier_value, Classifier_Weigths);
New_dataBase.RulesDatabase.Add(temp_rule);
}
result.RulesDatabaseSet.Clear();
result.RulesDatabaseSet.Add(New_dataBase);
GC.Collect();
return(result);
}
