public override FuzzySystem.SingletoneApproximate.SAFuzzySystem TuneUpFuzzySystem(FuzzySystem.SingletoneApproximate.SAFuzzySystem Approximate, ILearnAlgorithmConf conf) { Mnk_lib.Mnk_class Mnk_me = new Mnk_lib.Mnk_class(); double [,,] Extracted_rules = extract_Rules(Approximate.RulesDatabaseSet[0]); double [,] Extracted_Samples = extract_Sample_table(Approximate.LearnSamplesSet); double [] Extracted_Samples_out = extract_Sample_table_Out(Approximate.LearnSamplesSet); int count_rules = Approximate.RulesDatabaseSet[0].RulesDatabase.Count; int count_samples = Approximate.LearnSamplesSet.CountSamples; int count_Vars = Approximate.LearnSamplesSet.CountVars; double [] New_consq = new double[count_rules]; TypeTermFuncEnum type_Func = Approximate.RulesDatabaseSet[0].TermsSet[0].TermFuncType; 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); SAFuzzySystem Result = Approximate; double result_before = Result.approxLearnSamples(Result.RulesDatabaseSet[0]); double [] Back_consq = Result.RulesDatabaseSet[0].all_conq_of_rules; Result.RulesDatabaseSet[0].all_conq_of_rules = New_consq; double result_after = Result.approxLearnSamples(Result.RulesDatabaseSet[0]); if (result_before < result_after) { Result.RulesDatabaseSet[0].all_conq_of_rules = Back_consq; } GC.Collect(); Result.RulesDatabaseSet[0].TermsSet.Trim(); return(Result); }
public override PCFuzzySystem Generate(PCFuzzySystem Classifier, IGeneratorConf config) { PCFuzzySystem result = Classifier; if (result.RulesDatabaseSet.Count == 0) { AbstractNotSafeGenerator tempGen = new GeneratorRulesEveryoneWithEveryone(); result = tempGen.Generate(result, config); GC.Collect(); } count_shrink = ((TermShrinkAndRotateConf)config).TSARCShrinkVars; size_shrink = ((TermShrinkAndRotateConf)config).TSARCShrinkTerm; type_func = ((TermShrinkAndRotateConf)config).IEWEFuncType; count_slices = ((TermShrinkAndRotateConf)config).IEWECountSlice; List <int> Varians_of_run_system = new List <int>(); for (int i = 0; i < Classifier.CountFeatures; i++) { int count_terms_for_var = Classifier.RulesDatabaseSet[0].TermsSet.FindAll(x => x.NumVar == 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(); TypeTermFuncEnum type_of_term = Classifier.RulesDatabaseSet[0].TermsSet[0].TermFuncType; Generate_all_variant_in_pool(Varians_of_run_system); for (int i = 0; i < Pull_of_systems.Count; i++) { Classifier.RulesDatabaseSet.Clear(); GeneratorRulesEveryoneWithEveryone.InitRulesEveryoneWithEveryone(Classifier, type_of_term, Pull_of_systems[i].ToArray()); Systems_ready_to_test.Add(Classifier.RulesDatabaseSet[0]); errors_of_systems.Add(result.ErrorLearnSamples(result.RulesDatabaseSet[0])); } int best_index = errors_of_systems.IndexOf(errors_of_systems.Min()); result.RulesDatabaseSet.Clear(); result.RulesDatabaseSet.Add(Systems_ready_to_test[best_index]); Console.WriteLine(Pull_of_systems.Count()); GC.Collect(); // result.UnlaidProtectionFix(); result.RulesDatabaseSet[0].TermsSet.Trim(); return(result); }
/// <summary> /// Метод расчитывающий вектор параметров по заданому значению пика функции принадлежности, разбросу отностельно центра и типу функции принадлежности. /// </summary> /// <param name="Center">Значении пика (центра) функции принадлежности</param> /// <param name="distance">Разбросу отностельно пика (центра) функции принадлежности</param> /// <param name="TypeTerm">Тип функции принадлежности</param> /// <returns>Вектор параметров функции принадлежности</returns> public static double[] GenTermParams(double Center, double distance, TypeTermFuncEnum TypeTerm) { double[] result = new double[CountParamsinSelectedTermType(TypeTerm)]; switch (TypeTerm) { case TypeTermFuncEnum.Гауссоида: { result[0] = Center; result[1] = distance / 3.0; } break; case TypeTermFuncEnum.Треугольник: { result[0] = Center - distance; result[1] = Center; result[2] = Center + distance; } break; case TypeTermFuncEnum.Парабола: { result[0] = Center - distance; result[1] = Center + distance; } break; case TypeTermFuncEnum.Трапеция: { 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); }
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); } }
protected override void fill_params(string[] args) { file_learn = (args.Where(x => x.Contains("tra"))).ToArray()[0]; Console.WriteLine("Before cut {0}", file_learn); file_learn = file_learn.Remove(0, 4); Console.WriteLine("After cut {0}", file_learn); file_test = (args.Where(x => x.Contains("tst"))).ToArray()[0]; file_test = file_test.Remove(0, 4); file_out = (args.Where(x => x.Contains("out"))).ToArray()[0]; file_out = file_out.Remove(0, 4); string temp = (args.Where(x => x.Contains("typeFunc"))).ToArray()[0]; switch (temp) { case "Triangle": func = TypeTermFuncEnum.Треугольник; break; case "Gauss": func = TypeTermFuncEnum.Гауссоида; break; case "Parabola": func = TypeTermFuncEnum.Парабола; break; case "Trapezium": func = TypeTermFuncEnum.Трапеция; break; default: func = TypeTermFuncEnum.Треугольник; break; } }
protected override void fill_params(string[] args) { file_learn = (args.Where(x => x.Contains("tra"))).ToArray()[0]; Console.WriteLine("Before cut {0}", file_learn); file_learn = file_learn.Remove(0, 4); Console.WriteLine("After cut {0}", file_learn); file_test = (args.Where(x => x.Contains("tst"))).ToArray()[0]; file_test = file_test.Remove(0, 4); file_out = (args.Where(x => x.Contains("out"))).ToArray()[0]; file_out = file_out.Remove(0, 4); int temp_i = 0; string temp = (args.Where(x => x.Contains("CountN1"))).ToArray()[0]; int.TryParse(temp, out temp_i); CountN[0] = temp_i; temp = (args.Where(x => x.Contains("CountN2"))).ToArray()[0]; int.TryParse(temp, out temp_i); CountN[1] = temp_i; temp = (args.Where(x => x.Contains("CountN3"))).ToArray()[0]; int.TryParse(temp, out temp_i); CountN[2] = temp_i; temp = (args.Where(x => x.Contains("CountN4"))).ToArray()[0]; int.TryParse(temp, out temp_i); CountN[3] = temp_i; temp = (args.Where(x => x.Contains("CountN5"))).ToArray()[0]; int.TryParse(temp, out temp_i); CountN[4] = temp_i; temp = (args.Where(x => x.Contains("CountN6"))).ToArray()[0]; int.TryParse(temp, out temp_i); CountN[5] = temp_i; temp = (args.Where(x => x.Contains("CountN7"))).ToArray()[0]; int.TryParse(temp, out temp_i); CountN[6] = temp_i; temp = (args.Where(x => x.Contains("CountN8"))).ToArray()[0]; int.TryParse(temp, out temp_i); CountN[7] = temp_i; temp = (args.Where(x => x.Contains("typeFunc"))).ToArray()[0]; switch (temp) { case "Triangle": func = TypeTermFuncEnum.Треугольник; break; case "Gauss": func = TypeTermFuncEnum.Гауссоида; break; case "Parabola": func = TypeTermFuncEnum.Парабола; break; case "Trapezium": func = TypeTermFuncEnum.Трапеция; break; default: func = TypeTermFuncEnum.Треугольник; break; } }
public virtual void Init(int countVars) { type_term_func = (TypeTermFuncEnum)Settings.Default.Type_func_int; count_terms = new int[countVars]; for (int i = 0; i < countVars; i++) { count_terms[i] = Settings.Default.AvrCountTerms; } }
public override TSAFuzzySystem Generate(TSAFuzzySystem Approximate, IGeneratorConf config) { start_add_rules = Approximate.RulesDatabaseSet.Count; TSAFuzzySystem result = Approximate; if (result.RulesDatabaseSet.Count == 0) { AbstractNotSafeGenerator tempGen = new GeneratorRulesEveryoneWithEveryone(); result = tempGen.Generate(result, config); GC.Collect(); } Request_count_rules = ((RullesShrinkConf)config).RSCCountRules; max_count_rules = ((RullesShrinkConf)config).RSCMaxRules; count_slices = ((RullesShrinkConf)config).IEWECountSlice; min_count_rules = ((RullesShrinkConf)config).RSCMinRules; type_term = ((RullesShrinkConf)config).IEWEFuncType; int count_of_swith_off = ((RullesShrinkConf)config).RSCMaxRules - Request_count_rules; List <byte> Varians_of_run_system = new List <byte>(); for (int i = 0; i < Approximate.RulesDatabaseSet[0].RulesDatabase.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++) { KnowlegeBaseTSARules temp_rules = new KnowlegeBaseTSARules(result.RulesDatabaseSet[0], Pull_of_systems[i]); temp_rules.TrimTerms(); result.RulesDatabaseSet.Add(temp_rules); result.UnlaidProtectionFix(result.RulesDatabaseSet[start_add_rules + i]); errors_of_systems.Add(result.approxLearnSamples(result.RulesDatabaseSet [start_add_rules + i])); } int best_index = errors_of_systems.IndexOf(errors_of_systems.Min()); KnowlegeBaseTSARules best = result.RulesDatabaseSet[start_add_rules + best_index]; result.RulesDatabaseSet.Clear(); result.RulesDatabaseSet.Add(best); Console.WriteLine(Pull_of_systems.Count()); GC.Collect(); // result.UnlaidProtectionFix(); result.RulesDatabaseSet[0].TermsSet.Trim(); return(result); }
public override TSAFuzzySystem TuneUpFuzzySystem(TSAFuzzySystem Approximate, ILearnAlgorithmConf config) { TSAFuzzySystem result = Approximate; if (result.RulesDatabaseSet.Count == 0) { throw new System.FormatException("Что то не то с входными данными"); } OptimizeTermShrinkAndRotateConf Config = config as OptimizeTermShrinkAndRotateConf; count_shrink = Config.OTSARCountShrinkVars; size_shrink = Config.OTSARCountShrinkTerm; List <int> Varians_of_run_system = new List <int>(); for (int i = 0; i < Approximate.CountFeatures; i++) { int count_terms_for_var = Approximate.RulesDatabaseSet[0].TermsSet.FindAll(x => x.NumVar == 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(); TypeTermFuncEnum type_of_term = Approximate.RulesDatabaseSet[0].TermsSet[0].TermFuncType; Generate_all_variant_in_pool(Varians_of_run_system); for (int i = 0; i < Pull_of_systems.Count; i++) { Approximate.RulesDatabaseSet.Clear(); GeneratorRulesEveryoneWithEveryone.InitRulesEveryoneWithEveryone(result, type_of_term, Pull_of_systems[i].ToArray()); Systems_ready_to_test.Add(Approximate.RulesDatabaseSet[0]); errors_of_systems.Add(result.approxLearnSamples(result.RulesDatabaseSet[0])); } int best_index = errors_of_systems.IndexOf(errors_of_systems.Min()); result.RulesDatabaseSet.Clear(); result.RulesDatabaseSet.Add(Systems_ready_to_test[best_index]); Console.WriteLine(Pull_of_systems.Count()); result.RulesDatabaseSet[0].TermsSet.Trim(); // result.UnlaidProtectionFix(); return(result); }
public override SAFuzzySystem Generate(SAFuzzySystem Approximate, IGeneratorConf config) { SAFuzzySystem result = Approximate; InitEveryoneWithEveryone config1 = config as InitEveryoneWithEveryone; type_func = config1.IEWEFuncType; count_slice_vars = config1.IEWECountSlice; InitRulesEveryoneWithEveryone(Approximate, type_func, count_slice_vars); return(result); }
public override TSAFuzzySystem Generate(TSAFuzzySystem Approximate, IGeneratorConf config) { type_alg = ((kMeanRulesGeneratorConfig)config).KMRGTypeAlg; count_rules = ((kMeanRulesGeneratorConfig)config).KMRGCountRules; type_func = ((kMeanRulesGeneratorConfig)config).KMRGTypeFunc; nebulisation_factor = ((kMeanRulesGeneratorConfig)config).KMRGExponentialWeight; Max_iteration = ((kMeanRulesGeneratorConfig)config).KMRGIteraton; need_precision = ((kMeanRulesGeneratorConfig)config).KMRGAccuracy; Approxk_mean_base K_Agl = null; switch (type_alg) { case Type_k_mean_algorithm.GathGeva: K_Agl = new Approxk_mean_Gath_Geva(Approximate.LearnSamplesSet, Max_iteration, need_precision, count_rules, nebulisation_factor); break; case Type_k_mean_algorithm.GustafsonKessel: K_Agl = new Approxk_mean_Gustafson_kessel(Approximate.LearnSamplesSet, Max_iteration, need_precision, count_rules, nebulisation_factor); break; case Type_k_mean_algorithm.FCM: K_Agl = new Approxk_mean_base(Approximate.LearnSamplesSet, Max_iteration, need_precision, count_rules, nebulisation_factor); break; } K_Agl.Calc(); KnowlegeBaseTSARules New_Rules = new KnowlegeBaseTSARules(); for (int i = 0; i < count_rules; i++) { int [] order_terms = new int [Approximate.LearnSamplesSet.CountVars]; List <Term> term_set = new List <Term>(); for (int j = 0; j < Approximate.LearnSamplesSet.CountVars; j++) { Term temp_term = Term.MakeTerm(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.ConstructNewRule(term_set, Approximate); } TSAFuzzySystem Result = Approximate; if (Result.RulesDatabaseSet.Count > 0) { Result.RulesDatabaseSet[0] = New_Rules; } else { Result.RulesDatabaseSet.Add(New_Rules); } Result.UnlaidProtectionFix(Result.RulesDatabaseSet[0]); GC.Collect(); Result.RulesDatabaseSet[0].TermsSet.Trim(); return(Result); }
/// <summary> /// Функция преобразование типа функции принадлежности в текстовое описание /// </summary> /// <param name="tf">Тип функции принадлежности</param> /// <returns>Строка с названием типа функции принадлежности</returns> public static string ToStringTypeTerm(TypeTermFuncEnum tf) { switch (tf) { case TypeTermFuncEnum.Гауссоида: return("Гауссоида"); case TypeTermFuncEnum.Парабола: return("Парабола"); case TypeTermFuncEnum.Трапеция: return("Трапеция"); case TypeTermFuncEnum.Треугольник: return("Треугольник"); } return("Треугольная"); }
public override PCFuzzySystem Generate(PCFuzzySystem Classifier, IGeneratorConf config) { PCFuzzySystem result = Classifier; Systems_ready_to_test = new List <KnowlegeBasePCRules>(); errors_of_systems = new List <double>(); InitEveryoneWithEveryone config1 = config as InitEveryoneWithEveryone; type_func = config1.IEWEFuncType; count_slice_vars = config1.IEWECountSlice; List <int> Varians_of_run_system = new List <int>(); for (int i = 0; i < Classifier.CountFeatures; i++) { int count_terms_for_var = count_slice_vars[i]; Varians_of_run_system.Add(count_terms_for_var); } Varians_of_run_system.Sort(); Generate_all_variant_in_pool(Varians_of_run_system); for (int i = 0; i < Pull_of_systems.Count; i++) { Classifier.RulesDatabaseSet.Clear(); GeneratorRulesEveryoneWithEveryone.InitRulesEveryoneWithEveryone(result, type_func, Pull_of_systems[i].ToArray()); Systems_ready_to_test.Add(Classifier.RulesDatabaseSet[0]); errors_of_systems.Add(result.ErrorLearnSamples(result.RulesDatabaseSet[0])); } int best_index = errors_of_systems.IndexOf(errors_of_systems.Min()); result.RulesDatabaseSet.Clear(); result.RulesDatabaseSet.Add(Systems_ready_to_test[best_index]); for (int i = 0; i < count_slice_vars.Count(); i++) { count_slice_vars[i] = result.RulesDatabaseSet[0].TermsSet.Count(x => x.NumVar == i); } Console.WriteLine(Pull_of_systems.Count()); GC.Collect(); result.RulesDatabaseSet[0].TermsSet.Trim(); return(result); }
public virtual void Init(ILearnAlgorithmConf Config) { this.Config = Config as BeeStructureConf; countScouts = this.Config.ABCSCountScout; countWorkers = this.Config.ABCSCountWorkers; countRules = this.Config.ABCSCountRules; typeTerm = this.Config.ABCSTypeFunc; theScouts = new Scout[countScouts]; theWorkers = new Worker[countWorkers * 3]; if (theFuzzySystem.RulesDatabaseSet.Count < 1) { throw (new Exception("Что то не так с базой правил")); } }
public override SAFuzzySystem Generate(SAFuzzySystem Approximate, IGeneratorConf config) { SAFuzzySystem result = Approximate; Systems_ready_to_test = new List <KnowlegeBaseSARules>(); errors_of_systems = new List <double>(); InitEveryoneWithOptimal config1 = config as InitEveryoneWithOptimal; type_func = config1.IEWOTypeFunc; count_slice_vars = config1.count_terms; List <int> Varians_of_run_system = new List <int>(); for (int i = 0; i < Approximate.CountFeatures; i++) { int count_terms_for_var = count_slice_vars[i]; Varians_of_run_system.Add(count_terms_for_var); } Varians_of_run_system.Sort(); Generate_all_variant_in_pool(Varians_of_run_system); for (int i = 0; i < Pull_of_systems.Count; i++) { Approximate.RulesDatabaseSet.Clear(); GeneratorRulesEveryoneWithEveryone.InitRulesEveryoneWithEveryone(Approximate, type_func, Pull_of_systems[i].ToArray()); Systems_ready_to_test.Add(Approximate.RulesDatabaseSet[0]); errors_of_systems.Add(result.approxLearnSamples(result.RulesDatabaseSet[0])); } int best_index = errors_of_systems.IndexOf(errors_of_systems.Min()); result.RulesDatabaseSet.Clear(); result.RulesDatabaseSet.Add(Systems_ready_to_test[best_index]); for (int i = 0; i < count_slice_vars.Count(); i++) { count_slice_vars[i] = result.RulesDatabaseSet[0].TermsSet.Count(x => x.NumVar == i); } Console.WriteLine(Pull_of_systems.Count()); result.RulesDatabaseSet[0].TermsSet.Trim(); GC.Collect(); return(result); }
public void generateNewRule(TypeTermFuncEnum termType, Random rand) { int CountVaribles = Parrent.CountFeatures; forClass.Clear(); numOfTerms = new int[CountVaribles]; for (int i = 0; i < CountVaribles; i++) { double min = Parrent.LearnSamplesSet.InputAttributes[i].Min; double max = Parrent.LearnSamplesSet.InputAttributes[i].Max; double Scatter = Parrent.LearnSamplesSet.InputAttributes[i].Scatter; double[] Params = null; Term newTerm = null; switch (termType) { case TypeTermFuncEnum.Гауссоида: { Params = generateGauss(min, max, Scatter, rand); } break; case TypeTermFuncEnum.Парабола: { Params = generateParabolic(min, max, Scatter, rand); } break; case TypeTermFuncEnum.Трапеция: { Params = generateTrapec(min, max, Scatter, rand); Params = inValidateTrapec(Params, min, max, Scatter, rand); } break; case TypeTermFuncEnum.Треугольник: { Params = generateTrianlge(min, max, Scatter, rand); Params = inValidateTriangle(Params, min, max, Scatter, rand); } break; } newTerm = new Term(Params, termType, i); forClass.Add(newTerm); thePositionOfBee.TermsSet.Add(newTerm); numOfTerms[i] = thePositionOfBee.TermsSet.Count() - 1; } makeKons(Parrent, forClass); thePositionOfBee.RulesDatabase.Add(theRule); numoFRules = thePositionOfBee.RulesDatabase.Count - 1; }
/// <summary> /// Размер вектора параметров для заданного типа функции принадлежности. /// </summary> /// <param name="tf">Тип функции принадлежности</param> /// <returns>Размер вектора параметров</returns> public static int CountParamsinSelectedTermType(TypeTermFuncEnum tf) { switch (tf) { case TypeTermFuncEnum.Треугольник: return(3); case TypeTermFuncEnum.Гауссоида: return(2); case TypeTermFuncEnum.Парабола: return(2); case TypeTermFuncEnum.Трапеция: return(4); } return(0); }
public override PCFuzzySystem Generate(PCFuzzySystem Classifier, IGeneratorConf config) { PCFuzzySystem result = Classifier; InitEveryoneWithEveryone config1 = config as InitEveryoneWithEveryone; type_func = config1.IEWEFuncType; count_slice_vars = config1.IEWECountSlice; InitRulesEveryoneWithEveryone(result, type_func, count_slice_vars); InitRulesEveryoneWithEveryone(result, type_func, count_slice_vars); result.RulesDatabaseSet[0].TermsSet.Trim(); return(result); }
public void loadParams(string param) { string stemp = ""; string[] temp = param.Split('}'); stemp = Extention.getParamValueString(temp, "IBSTypeFunc"); switch (stemp) { case "Triangle": IBSTypeFunc = TypeTermFuncEnum.Треугольник; break; case "Gauss": IBSTypeFunc = TypeTermFuncEnum.Гауссоида; break; case "Parabola": IBSTypeFunc = TypeTermFuncEnum.Парабола; break; case "Trapezium": IBSTypeFunc = TypeTermFuncEnum.Трапеция; break; default: IBSTypeFunc = TypeTermFuncEnum.Треугольник; break; } }
public override TSAFuzzySystem Generate(TSAFuzzySystem Approximate, IGeneratorConf config) { ResultSystem = Approximate; type_func = TypeTermFuncEnum.Гауссоида; var kliConf = config as KLI_conf; if (kliConf != null) { { ResultSystem = Approximate; double meanValue = ResultSystem.LearnSamplesSet.DataRows.Select(x => x.DoubleOutput).Average(); var mayError = kliConf.MaxValue * meanValue; kliGenerate(ResultSystem, type_func, mayError); // File.AppendAllLines("./out.txt", new List<string>() { mayError + " " + Result.RulesDatabaseSet[0].ValueComplexity + " " + Result.RMSEtoMSEforLearn(Result.ErrorLearnSamples()) / 2 + " " + Result.RMSEtoMSEforTest(Result.ErrorTestSamples()) / 2 }); } } return(ResultSystem); }
public virtual void Init(int countVars) { type_term_func = (TypeTermFuncEnum)Settings.Default.Type_func_int; count_terms = new int[countVars]; for (int i = 0; i < countVars; i++) { count_terms[i] = Settings.Default.AvrCountTerms; } string temp = ""; Array.Sort(count_terms); for (int i = 0; i < count_terms.Count() - 1; i++) { temp += count_terms[i].ToString() + ","; } temp += count_terms[count_terms.Count() - 1].ToString(); IEWOCountTerms = temp; }
public virtual void loadParams(string param) { string stemp = ""; string[] temp = param.Split('}'); ABCSCountScout = Extention.getParamValueInt(temp, "ABCSCountScout"); ABCSCountWorkers = Extention.getParamValueInt(temp, "ABCSCountWorkers"); ABCSCountRules = Extention.getParamValueInt(temp, "ABCSCountRules"); stemp = Extention.getParamValueString(temp, "ABCSTypeFunc"); switch (stemp) { case "Triangle": ABCSTypeFunc = TypeTermFuncEnum.Треугольник; break; case "Gauss": ABCSTypeFunc = TypeTermFuncEnum.Гауссоида; break; case "Parabola": ABCSTypeFunc = TypeTermFuncEnum.Парабола; break; case "Trapezium": ABCSTypeFunc = TypeTermFuncEnum.Трапеция; break; default: ABCSTypeFunc = TypeTermFuncEnum.Треугольник; break; } }
public override PCFuzzySystem Generate(PCFuzzySystem Classifier, IGeneratorConf config) { PCFuzzySystem result = Classifier; //Filtre(result); InitBySamplesConfig config1 = config as InitBySamplesConfig; type_func = config1.IBSTypeFunc; calc_min_max_for_class(result.LearnSamplesSet); InitRulesBySamples(Classifier, type_func); result.RulesDatabaseSet[0].TermsSet.Trim(); //Chiu(result); //Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(result.RulesDatabaseSet[0]), 2)); //Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(result.RulesDatabaseSet[0]), 2)); //Console.WriteLine(); return(result); }
public override SAFuzzySystem Generate(FuzzySystem.SingletoneApproximate.SAFuzzySystem Approximate, IGeneratorConf config) { Random rand = new Random(); SAFuzzySystem result = Approximate; if (result.RulesDatabaseSet.Count == 0) { KnowlegeBaseSARules temp_rules = new KnowlegeBaseSARules(); 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; } double DoubleOutput = KNNConsequent.NearestApprox(result, temp_term_list); SARule temp_Rule = new SARule(result.RulesDatabaseSet[0].TermsSet, order, DoubleOutput); result.RulesDatabaseSet[0].RulesDatabase.Add(temp_Rule); } result.RulesDatabaseSet[0].TermsSet.Trim(); result.UnlaidProtectionFix(result.RulesDatabaseSet[0]); GC.Collect(); return(result); }
public static SAFuzzySystem loadUFS(this SAFuzzySystem Approx, XmlDocument Source) { SAFuzzySystem result = Approx; KnowlegeBaseSARules New_dataBase = new KnowlegeBaseSARules(); 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 = Approx.LearnSamplesSet.InputAttributes.IndexOf(Approx.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"); double DoubleOutput = XmlConvert.ToDouble(consequnt_node.Attributes.GetNamedItem("Value").Value); SARule temp_rule = new SARule(New_dataBase.TermsSet, Order_term, DoubleOutput); New_dataBase.RulesDatabase.Add(temp_rule); } result.RulesDatabaseSet.Clear(); result.RulesDatabaseSet.Add(New_dataBase); GC.Collect(); return(result); }
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); } }
/// <summary> /// Конструктор для создания функции принадлежности /// </summary> /// <param name="paramtrs">Вектор параметров функции принадлежности</param> /// <param name="type_term">Тип функции принадлежности</param> /// <param name="num_var">Номер входного параметра для которого определена функция принадлежности</param> public Term(double[] paramtrs, TypeTermFuncEnum type_term, int num_var) { Parametrs = paramtrs; TermFuncType = type_term; NumVar = num_var; }
public override TSAFuzzySystem Generate(TSAFuzzySystem Approximate, IGeneratorConf config) { TSAFuzzySystem result = Approximate; Pull_of_systems = Pull_of_systems = new List <List <int> >(); Systems_ready_to_test = new List <KnowlegeBaseTSARules>(); errors_of_systems = new List <double>(); DynamicTuneConfGenerator config1 = config as DynamicTuneConfGenerator; type_func = config1.IEWOTypeFunc; List <int> Varians_of_run_system = new List <int>(); List <int> allOne = new List <int>(); for (int i = 0; i < Approximate.CountFeatures; i++) { allOne.Add(1); } Pull_of_systems.Add(new List <int>(allOne)); for (int j = 0; j < Approximate.CountFeatures - 1; j++) { Varians_of_run_system.Clear(); allOne[j] = 2; Varians_of_run_system.AddRange(new List <int> (allOne)); Varians_of_run_system.Sort(); Generate_all_variant_in_pool(Varians_of_run_system); } allOne[Approximate.CountFeatures - 1] = 2; Pull_of_systems.Add(new List <int> (allOne)); for (int i = 0; i < Pull_of_systems.Count; i++) { Approximate.RulesDatabaseSet.Clear(); GeneratorRulesEveryoneWithEveryone.InitRulesEveryoneWithEveryone(Approximate, type_func, Pull_of_systems[i].ToArray()); Systems_ready_to_test.Add(Approximate.RulesDatabaseSet[0]); errors_of_systems.Add(result.approxLearnSamples(result.RulesDatabaseSet[0])); } DynamicTuneClass dt = new DynamicTuneClass(); Approximate = dt.TuneUpFuzzySystem(Approximate, config1); Systems_ready_to_test.Add(Approximate.RulesDatabaseSet[0]); errors_of_systems.Add(result.approxLearnSamples(result.RulesDatabaseSet[0])); int best_index = errors_of_systems.IndexOf(errors_of_systems.Min()); result.RulesDatabaseSet.Clear(); result.RulesDatabaseSet.Add(Systems_ready_to_test[best_index]); count_slice_vars = new int[Approximate.CountFeatures]; for (int i = 0; i < count_slice_vars.Count(); i++) { count_slice_vars[i] = result.RulesDatabaseSet[0].TermsSet.Count(x => x.NumVar == i); } maxError = config1.MaxError; TryCount = config1.TryCount; RuleCount = result.RulesDatabaseSet[0].RulesDatabase.Count; Console.WriteLine(Pull_of_systems.Count()); result.RulesDatabaseSet[0].TermsSet.Trim(); GC.Collect(); return(result); }
public void kliGenerate(TSAFuzzySystem Approximate, TypeTermFuncEnum typeFunc, double mayError) { if ((Approximate.RulesDatabaseSet == null) || (Approximate.RulesDatabaseSet.Count == 0)) { Approximate.RulesDatabaseSet.Add(new KnowlegeBaseTSARules()); } originalSimpleSet = new List <SampleSet.RowSample>(Approximate.LearnSamplesSet.DataRows); originalSimpleSetDistanteToPoint = new List <double>(); CalcFarPoint(); int ruleIndex = 0; while (originalSimpleSet.Count > 0) { int IndexOfMax = originalSimpleSetDistanteToPoint.IndexOf(originalSimpleSetDistanteToPoint.Max()); var maxPoint = originalSimpleSet[IndexOfMax]; originalSimpleSet.Remove(maxPoint); originalSimpleSetDistanteToPoint.RemoveAt(IndexOfMax); var iterClasterPoints = new List <SampleSet.RowSample>() { maxPoint }; var mnk = new MNK() { n = maxPoint.InputAttributeValue.Count() }; var P = new Matrix(new[] { new double[] { 0 } }); var B = new HyperVector(0, 0); mnk.mnkIter(iterClasterPoints.Last().InputAttributeValue.ToList(), iterClasterPoints.Last().DoubleOutput, ref P, ref B, true); // var errorIter = errorsMnk(B, iterClasterPoints); for (int z = 0; z < Approximate.CountFeatures; z++) { int NextIndex2 = maxPoint.NearestNormalizedInputIndex(originalSimpleSet, ResultSystem.LearnSamplesSet); var nextPoint2 = originalSimpleSet[NextIndex2]; mnk.mnkIter(nextPoint2.InputAttributeValue.ToList(), nextPoint2.DoubleOutput, ref P, ref B, false); iterClasterPoints.Add(nextPoint2); originalSimpleSet.Remove(nextPoint2); } var errorIter = errorsMnk(B, iterClasterPoints); while (errorIter < mayError) { if (originalSimpleSet.Count < Approximate.CountFeatures) { while (originalSimpleSet.Count > 0) { int NextIndex2 = maxPoint.NearestNormalizedInputIndex(originalSimpleSet, ResultSystem.LearnSamplesSet); var nextPoint2 = originalSimpleSet[NextIndex2]; mnk.mnkIter(nextPoint2.InputAttributeValue.ToList(), nextPoint2.DoubleOutput, ref P, ref B, false); iterClasterPoints.Add(nextPoint2); originalSimpleSet.Remove(nextPoint2); originalSimpleSetDistanteToPoint.RemoveAt(NextIndex2); } break; } int NextIndex = maxPoint.NearestNormalizedInputIndex(originalSimpleSet, ResultSystem.LearnSamplesSet); var nextPoint = originalSimpleSet[NextIndex]; mnk.mnkIter(nextPoint.InputAttributeValue.ToList(), nextPoint.DoubleOutput, ref P, ref B, false); errorIter = errorsMnk(B, new List <SampleSet.RowSample>(iterClasterPoints) { nextPoint }); if (errorIter < mayError) { iterClasterPoints.Add(nextPoint); maxPoint = nextPoint; originalSimpleSet.Remove(nextPoint); originalSimpleSetDistanteToPoint.RemoveAt(NextIndex); } } var numbersRule = new List <int>(); List <Term> forRWLSM = new List <Term>(); for (int i = 0; i < Approximate.CountFeatures; i++) { var parametrs = new double[Term.CountParamsinSelectedTermType(typeFunc)]; parametrs[0] = iterClasterPoints.Sum(x => x.InputAttributeValue[i]) / iterClasterPoints.Count; parametrs[1] = Math.Sqrt( iterClasterPoints.Sum(x => Math.Pow(x.InputAttributeValue[i] - parametrs[0], 2.0)) / iterClasterPoints.Count); if (parametrs[1] < Math.Pow(10, -300)) { parametrs[1] = Approximate.LearnSamplesSet.InputAttributes[i].Scatter / 100.0; } var temp_term = new Term(parametrs, typeFunc, i); forRWLSM.Add(temp_term); Approximate.RulesDatabaseSet[0].TermsSet.Add(temp_term); numbersRule.Add(Approximate.RulesDatabaseSet[0].TermsSet.Count - 1); } ruleIndex++; double[] coeffs = null; double coef = LSMWeghtReqursiveSimple.EvaluteConsiquent(ResultSystem, forRWLSM, out coeffs); var temp_rule = new TSARule(Approximate.RulesDatabaseSet[0].TermsSet, numbersRule.ToArray(), coef, coeffs); Approximate.RulesDatabaseSet[0].RulesDatabase.Add(temp_rule); } }
/// <summary> /// Метод упращающий создание функции принадлежности. Использует значение пика (центра ) функции принадлежности, дистанцию (разброс отностительно центра), тип функции принадлежности и указание номер входной переменной /// </summary> /// <param name="center">значение пика (центра ) функции принадлежности</param> /// <param name="distance"> дистанция (разброс отностительно центра)</param> /// <param name="TypeTerm">тип функции принадлежности</param> /// <param name="NumVar">Номер входной переменной</param> /// <returns>Новая функция принадлежности</returns> public static Term MakeTerm(double center, double distance, TypeTermFuncEnum TypeTerm, int NumVar) { Term Result = new Term(GenTermParams(center, distance, TypeTerm), TypeTerm, NumVar); return(Result); }