private void calculateVHL(KnowlegeBasePCRules Explorer, KnowlegeBasePCRules ExplorerBestPosition) { KnowlegeBasePCRules part1 = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); KnowlegeBasePCRules part2 = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); for (int i = 0; i < part1.TermsSet.Count; i++) { for (int j = 0; j < part1.TermsSet[i].Parametrs.Length; j++) { part1.TermsSet[i].Parametrs[j] = (ExplorerBestPosition.TermsSet[i].Parametrs[j] - Explorer.TermsSet[i].Parametrs[j]) * AGlobal * rand.NextDouble(); // } } for (int i = 0; i < part2.TermsSet.Count; i++) { for (int j = 0; j < part2.TermsSet[i].Parametrs.Length; j++) { part2.TermsSet[i].Parametrs[j] = (HeadLeader.TermsSet[i].Parametrs[j] - Explorer.TermsSet[i].Parametrs[j]) * BGlobal * rand.NextDouble(); // } } for (int i = 0; i < VelocityVectorHL.TermsSet.Count; i++) { for (int j = 0; j < VelocityVectorHL.TermsSet[i].Parametrs.Length; j++) { VelocityVectorHL.TermsSet[i].Parametrs[j] = (part1.TermsSet[i].Parametrs[j] + part2.TermsSet[i].Parametrs[j]); // } } }
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 override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classifier, ILearnAlgorithmConf conf) { BacteryAlgorithmConfig Config = conf as BacteryAlgorithmConfig; sendBactery = Config.BFOCountSolution; interPSOtoSend = Config.BFOCountIteration; result = Classifier; if (result.RulesDatabaseSet.Count < 1) { throw new InvalidDataException("Нечеткая система не проинициализированна"); } KnowlegeBasePCRules backSave = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); double backResult = result.ErrorLearnSamples(result.RulesDatabaseSet[0]); savetoUFS(result.RulesDatabaseSet, 0, 0, 0); BacteryRunner(); KnowlegeBasePCRules[] solutions = loadDatabase(); solutions = sortSolution(solutions); if (solutions.Count() < 1) { result.RulesDatabaseSet[0] = backSave; return(result); } result.RulesDatabaseSet[0] = solutions[0]; double newResult = result.ErrorLearnSamples(result.RulesDatabaseSet[0]); if (newResult > backResult) { result.RulesDatabaseSet[0] = backSave; } result.RulesDatabaseSet[0].TermsSet.Trim(); return(result); }
private int findNearestLocalLeader(KnowlegeBasePCRules Explorer, int p_i) { int index = 0; double minimum = 999999999999; for (int k = 0; k < numberOfLocalLeaders; k++) { double distance = 0; for (int i = 0; i < LocalLeaders[p_i][k].TermsSet.Count; i++) { for (int j = 0; j < LocalLeaders[p_i][k].TermsSet[i].Parametrs.Length; j++) { distance += Math.Pow(Explorer.TermsSet[i].Parametrs[j] - LocalLeaders[p_i][k].TermsSet[i].Parametrs[j], 2); } } //for (int i = 0; i < Explorer.RulesDatabase.Count; i++) //{ // distance += Math.Pow(Explorer.RulesDatabase[i].Cons_DoubleOutput - LocalLeaders[k].RulesDatabase[i].Cons_DoubleOutput, 2); //} distance = Math.Sqrt(distance); if (distance < minimum) { minimum = distance; index = k; } } return(index); }
//нахождение расстояния между крилями private double Distance(KnowlegeBasePCRules x, KnowlegeBasePCRules y) { double dist, sum = 0; for (int i = 0; i < x.TermsSet.Count; i++) { for (int j = 0; j < x.TermsSet[i].Parametrs.Length; j++) { sum += Math.Pow(x.TermsSet[i].Parametrs[j] - y.TermsSet[i].Parametrs[j], 2); } } //for (int i = 0; i < x.RulesDatabase.Count; i++) //{ // sum += Math.Pow(x.RulesDatabase[i].Cons_DoubleOutput - y.RulesDatabase[i].Cons_DoubleOutput, 2); //} dist = Math.Sqrt(sum); /* #if debug * //вывод значение dist соседа * Console.Write("Значение dist = "); * Console.WriteLine(dist); #endif */ return(dist); }
private PCFuzzySystem BreakCrossTerm(PCFuzzySystem Classifier, int Feature, int indexATerm, int indexBterm, int dataBase) { PCFuzzySystem result = Classifier; KnowlegeBasePCRules DataSet = result.RulesDatabaseSet[dataBase]; List <Term> soureTerms = DataSet.TermsSet.Where(x => x.NumVar == Feature).ToList(); Term ATerm = soureTerms[indexATerm]; Term BTerm = soureTerms[indexBterm]; Term Left = ATerm; Term Right = BTerm; if (ATerm.Pick > BTerm.Pick) { Left = BTerm; Right = ATerm; } double border = (Left.Max + Right.Min) / 2; Left.Max = border; Right.Min = border; result.RulesDatabaseSet[dataBase] = DataSet; return(result); }
KnowlegeBasePCRules unifiedCrossover(KnowlegeBasePCRules parent1, KnowlegeBasePCRules parent2) { double b = (currentConf.GENCPopabilityCrossover / 100); KnowlegeBasePCRules child; child = new KnowlegeBasePCRules(parent1); for (int i = 0; i < parent1.TermsSet.Count; i++) //Parallel.For(0, parent1.TermsSet.Count, i => { if (b > allRandom.NextDouble()) { child.TermsSet[i].Parametrs = parent2.TermsSet[i].Parametrs; } //}); } double[] tempMassiveCh = child.Weigths.Clone() as double[]; double[] tempMassiveP2 = parent2.Weigths.Clone() as double[]; for (int i = 0; i < tempMassiveCh.Count(); i++) //Parallel.For(0, parent1.all_conq_of_rules.Count(), i => { if (b > allRandom.NextDouble()) { tempMassiveCh[i] = tempMassiveP2[i]; } } child.Weigths = tempMassiveCh; //}); return(child); }
public virtual void preIterate(PCFuzzySystem Classify, ILearnAlgorithmConf conf) { result = Classify; Init(conf); HeadLeader = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); VelocityVector = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); VelocityVectorLL = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); VelocityVectorHL = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); for (int i = 0; i < VelocityVector.TermsSet.Count; i++) { for (int j = 0; j < VelocityVector.TermsSet[i].Parametrs.Length; j++) { VelocityVector.TermsSet[i].Parametrs[j] = 0; VelocityVectorLL.TermsSet[i].Parametrs[j] = 0; VelocityVectorHL.TermsSet[i].Parametrs[j] = 0; } } SetPopulation(); ParticlesBest = new Dictionary <KnowlegeBasePCRules, KnowlegeBasePCRules>(); foreach (var Particle in Population) { ParticlesBest.Add(Particle, Universal); } LocalLeaders = new KnowlegeBasePCRules[numberOfLocalLeaders]; ExplorerParticles = new KnowlegeBasePCRules[numberOfAllParts - numberOfAimlessParts - numberOfLocalLeaders - 1]; AimlessParticles = new KnowlegeBasePCRules[numberOfAimlessParts]; iter = 0; Population = ListPittsburgClassifierTool.SortRules(Population, result); }
//нахождение расстояния ощущения (соседства) private List <int> countneihbors(KnowlegeBasePCRules x) { double border = distneihbor(x); List <int> neihbors = new List <int>(); /* * //вывод значение дистанции соседа * for (int g = 0; g < Population.Length; g++) * { * Console.Write("Знаение distneihbor = "); * Console.WriteLine(distneihbor(x)); * } */ for (int j = 0; j < Population.Length; j++) { if (x != Population[j]) { if (Distance(x, Population[j]) < border) { neihbors.Add(j); } } } return(neihbors); }
public void GetDots(PCFuzzySystem approx, KnowlegeBasePCRules knowlegeBase) { // Dots (COMPLETE, BUT DOUBLECHECK WHEN DEBUGGING) var inputs = approx.LearnSamplesSet.DataRows.AsParallel().AsOrdered() .Select(dataRow => dataRow.InputAttributeValue).ToList(); var localDots = inputs.AsParallel().AsOrdered() .Where(InBetweenTheLimits).ToList(); // var strs = new List<string[]>(localDots.Count); // for (int i = 0; i < strs.Capacity; i++) // strs.Add(new[] { string.Empty }); var rezs = approx.LearnSamplesSet.DataRows.AsParallel().AsOrdered() .Where(row => localDots.Contains(row.InputAttributeValue)) .Select(dataRow => dataRow.DoubleOutput).ToList(); List <SampleSet.RowSample> rows = localDots.Select((t, i) => new SampleSet.RowSample(t, null, rezs[i], null)).ToList(); var samples = new SampleSet("1.dat", rows, approx.LearnSamplesSet.InputAttributes, approx.LearnSamplesSet.OutputAttribute); system = new PCFuzzySystem(samples, samples); var usedRules = GetRules(knowlegeBase); system.RulesDatabaseSet.Add(new KnowlegeBasePCRules(knowlegeBase, null)); }
private void calculateVLL(KnowlegeBasePCRules Explorer, KnowlegeBasePCRules ExplorerBestPosition, int index, int p_i) { KnowlegeBasePCRules part1 = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); KnowlegeBasePCRules part2 = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); for (int i = 0; i < part1.TermsSet.Count; i++) { for (int j = 0; j < part1.TermsSet[i].Parametrs.Length; j++) { part1.TermsSet[i].Parametrs[j] = (ExplorerBestPosition.TermsSet[i].Parametrs[j] - Explorer.TermsSet[i].Parametrs[j]) * ALocal * rand.NextDouble(); } } for (int i = 0; i < part2.TermsSet.Count; i++) { for (int j = 0; j < part2.TermsSet[i].Parametrs.Length; j++) { part2.TermsSet[i].Parametrs[j] = (LocalLeaders[p_i][index].TermsSet[i].Parametrs[j] - Explorer.TermsSet[i].Parametrs[j]) * BLocal * rand.NextDouble(); } } for (int i = 0; i < VelocityVectorLL[p_i].TermsSet.Count; i++) { for (int j = 0; j < VelocityVectorLL[p_i].TermsSet[i].Parametrs.Length; j++) { VelocityVectorLL[p_i].TermsSet[i].Parametrs[j] = (part1.TermsSet[i].Parametrs[j] + part2.TermsSet[i].Parametrs[j]); } } }
private void ChangeExplorerPositions(int i, int p_i) { KnowlegeBasePCRules temp = new KnowlegeBasePCRules(); temp = ExplorerParticles[p_i][i]; for (int k = 0; k < temp.TermsSet.Count; k++) { for (int j = 0; j < temp.TermsSet[k].Parametrs.Length; j++) { temp.TermsSet[k].Parametrs[j] += VelocityVector[p_i].TermsSet[k].Parametrs[j]; } } if (result.ClassifyLearnSamples(ExplorerParticles[p_i][i]) < result.ClassifyLearnSamples(ParticlesBest[p_i][ExplorerParticles[p_i][i]])) { ParticlesBest[p_i].Remove(ExplorerParticles[p_i][i]); ParticlesBest[p_i].Add(temp, ExplorerParticles[p_i][i]); } else { KnowlegeBasePCRules tmp = new KnowlegeBasePCRules(); tmp = ParticlesBest[p_i][ExplorerParticles[p_i][i]]; ParticlesBest[p_i].Remove(ExplorerParticles[p_i][i]); ParticlesBest[p_i].Add(temp, tmp); } ExplorerParticles[p_i][i] = temp; }
//нахождение расстояния ощущения (соседства) private double distneihbor(KnowlegeBasePCRules x) { double sum = 0, dneihbor; for (int j = 0; j < Population.Length; j++) { if (x != Population[j]) { sum += Distance(x, Population[j]); } /* #if debug * //вывод значение суммы расстояний между переменными * Console.Write("Значение суммы для расчета расстояния ощущения = "); * Console.WriteLine(sum); #endif */ } dneihbor = sum * (1.0 / (5.0 * Population.Length)); /* * //вывод значение dneihbor соседей * Console.Write("Значение dneihbor для расчета расстояния ощущения = "); * Console.WriteLine(dneihbor); */ return(dneihbor); }
private List <KnowlegeBasePCRules> SetPopulation(List <KnowlegeBasePCRules> Population) { KnowlegeBasePCRules TempRule = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); Population.Add(TempRule); Universal = TempRule; for (int i = 1; i < numberOfAllParts; i++) { Population.Add(new KnowlegeBasePCRules(TempRule)); for (int j = 0; j < Population[i].TermsSet.Count; j++) { for (int k = 0; k < Population[i].TermsSet[j].Parametrs.Length; k++) { Population[i].TermsSet[j].Parametrs[k] = GaussRandom.Random_gaussian(rand, Population[i].TermsSet[j].Parametrs[k], 0.1 * Population[i].TermsSet[j].Parametrs[k]); } } result.UnlaidProtectionFix(Population[i]); } Universal = new KnowlegeBasePCRules(TempRule); for (int i = 0; i < Universal.TermsSet.Count; i++) { for (int j = 0; j < Universal.TermsSet[i].Parametrs.Length; j++) { Universal.TermsSet[i].Parametrs[j] = GaussRandom.Random_gaussian(rand, Universal.TermsSet[i].Parametrs[j], 0.1 * Universal.TermsSet[i].Parametrs[j]); } } return(Population); }
public static void Inject(this KnowlegeBasePCRules[] Destination, int indexStartDestination, KnowlegeBasePCRules[] Source, int indexStartSource, int CountIjected, PCFuzzySystem Classifier) { Destination = Destination.SortRules(Classifier); for (int i = 0; i < CountIjected; i++) { Destination[i + indexStartDestination] = new KnowlegeBasePCRules(Source[i + indexStartSource]); } }
public virtual void oneIterate(PCFuzzySystem result) { 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].TermsSet.Count; k++) { for (int q = 0; q < X[j].TermsSet[k].CountParams; q++) { double bp = Pi[j].TermsSet[k].Parametrs[q]; V[j].TermsSet[k].Parametrs[q] = V[j].TermsSet[k].Parametrs[q] * w + c1 * rnd.NextDouble() * (bp - X[j].TermsSet[k].Parametrs[q]) + c2 * rnd.NextDouble() * (Pg.TermsSet[k].Parametrs[q] - X[j].TermsSet[k].Parametrs[q]); X[j].TermsSet[k].Parametrs[q] += V[j].TermsSet[k].Parametrs[q]; } } double[] bf = new double[V[j].Weigths.Length]; double[] bfw = new double[V[j].Weigths.Length]; for (int k = 0; k < V[j].Weigths.Length; k++) { bfw[k] = V[j].Weigths[k] * w + c1 * rnd.NextDouble() * (Pi[j].Weigths[k] - X[j].Weigths[k]) + c2 * rnd.NextDouble() * (Pg.Weigths[k] - X[j].Weigths[k]); double sw = X[j].Weigths[k] + bfw[k]; if (sw > 0 && sw <= 2) { bf[k] = sw; } else { bf[k] = X[j].Weigths[k]; bfw[k] = V[j].Weigths[k]; } } X[j].Weigths = bf; V[j].Weigths = bfw; double newError = 0; bool success = true; try { newError = result.ClassifyLearnSamples(X[j]); } catch (Exception) { success = false; } if (success && (newError > Errors[j])) { OldErrors[j] = Errors[j]; Errors[j] = newError; Pi[j] = new KnowlegeBasePCRules(X[j]); } if (minError < newError) { minError = newError; Pg = new KnowlegeBasePCRules(X[j]); } } }
public override PCFuzzySystem Generate(PCFuzzySystem Classifier, IGeneratorConf config) { start_add_rules = Classifier.RulesDatabaseSet.Count; PCFuzzySystem result = Classifier; 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 < Classifier.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++) { KnowlegeBasePCRules temp_rules = new KnowlegeBasePCRules(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.ErrorLearnSamples(result.RulesDatabaseSet[start_add_rules + i])); } int best_index = errors_of_systems.IndexOf(errors_of_systems.Min()); KnowlegeBasePCRules 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 virtual void WJVector_gen(int j) { WJVector = new KnowlegeBasePCRules(monkey[j]); for (int k = 0; k < monkey[j].TermsSet.Count; k++) { for (int q = 0; q < monkey[j].TermsSet[k].CountParams; q++) { WJVector.TermsSet[k].Parametrs[q] += 2 * (StaticRandom.NextDouble() - 0.5) * watch_jump_parameter; } } }
private PCFuzzySystem UniTerm(PCFuzzySystem Classifier, int Feature, int indexATerm, int indexBterm, int dataBase) { PCFuzzySystem result = Classifier; KnowlegeBasePCRules DataSet = result.RulesDatabaseSet[dataBase]; List <Term> soureTerms = DataSet.TermsSet.Where(x => x.NumVar == Feature).ToList(); Term ATerm = soureTerms[indexATerm]; Term BTerm = soureTerms[indexBterm]; double newPick = (ATerm.Pick + BTerm.Pick) / 2; double newMin = ATerm.Min; if (BTerm.Min < newMin) { newMin = BTerm.Min; } double newMax = ATerm.Max; if (BTerm.Max > newMax) { newMax = BTerm.Max; } Term uniTerm = new Term(ATerm); uniTerm.Pick = newPick; uniTerm.Min = newMin; uniTerm.Max = newMax; DataSet.TermsSet.Add(uniTerm); List <PCRule> toChangeArules = DataSet.RulesDatabase.Where(x => x.ListTermsInRule.Contains(ATerm)).ToList(); for (int i = 0; i < toChangeArules.Count(); i++) { int indexofA = toChangeArules[i].ListTermsInRule.IndexOf(ATerm); toChangeArules[i].ListTermsInRule[indexofA] = uniTerm; } DataSet.TermsSet.Remove(ATerm); List <PCRule> toChangeBrules = DataSet.RulesDatabase.Where(x => x.ListTermsInRule.Contains(BTerm)).ToList(); for (int i = 0; i < toChangeBrules.Count(); i++) { int indexofB = toChangeBrules[i].ListTermsInRule.IndexOf(BTerm); toChangeBrules[i].ListTermsInRule[indexofB] = uniTerm; } DataSet.TermsSet.Remove(BTerm); result.RulesDatabaseSet[dataBase] = DataSet; return(result); }
private void ChangeAimlessPosition(KnowlegeBasePCRules Aimless, int p_i) { KnowlegeBasePCRules GlobalRand = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); SSVector_gen(p_i); for (int i = 0; i < Aimless.TermsSet.Count; i++) { for (int j = 0; j < Aimless.TermsSet[i].Parametrs.Length; j++) { Aimless.TermsSet[i].Parametrs[j] = ((rand.NextDouble() * 1.5 + 0.5) * (SSVector[p_i].TermsSet[i].Parametrs[j])); } } }
public virtual void Final() { KnowlegeBasePCRules best = main_pop.get_best_database(); double errorBest = result.ErrorLearnSamples(best); double currentError = result.ErrorLearnSamples(result.RulesDatabaseSet[0]); if (currentError > errorBest) { result.RulesDatabaseSet[0] = main_pop.get_best_database(); } result.RulesDatabaseSet[0] = main_pop.get_best_database(); GC.Collect(); }
private double Distance(KnowlegeBasePCRules x, KnowlegeBasePCRules y) { double sum = 0; for (int i = 0; i < x.TermsSet.Count; i++) { for (int j = 0; j < x.TermsSet[i].Parametrs.Length; j++) { sum += Math.Pow(x.TermsSet[i].Parametrs[j] - y.TermsSet[i].Parametrs[j], 2); } } return(sum); }
public override PCFuzzySystem Generate(PCFuzzySystem Classifier, 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; Classifierk_mean_base K_Agl = null; switch (type_alg) { case Type_k_mean_algorithm.GathGeva: K_Agl = new Classifierk_mean_Gath_Geva(Classifier.LearnSamplesSet, Max_iteration, need_precision, count_rules, nebulisation_factor); break; case Type_k_mean_algorithm.GustafsonKessel: K_Agl = new Classifierk_mean_Gustafson_kessel(Classifier.LearnSamplesSet, Max_iteration, need_precision, count_rules, nebulisation_factor); break; case Type_k_mean_algorithm.FCM: K_Agl = new Classifierk_mean_base(Classifier.LearnSamplesSet, Max_iteration, need_precision, count_rules, nebulisation_factor); break; } K_Agl.Calc(); KnowlegeBasePCRules New_Rules = new KnowlegeBasePCRules(); for (int i = 0; i < count_rules; i++) { int [] order_terms = new int [Classifier.LearnSamplesSet.CountVars]; List <Term> term_set = new List <Term>(); for (int j = 0; j < Classifier.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, Classifier); } PCFuzzySystem Result = Classifier; 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); }
void fullInit() { populationMassive = new KnowlegeBasePCRules[currentConf.GENCPopulationSize]; childrenMassive = new KnowlegeBasePCRules[currentConf.GENCCountChild]; for (int i = 0; i < currentConf.GENCPopulationSize; i++) { populationMassive[i] = new KnowlegeBasePCRules(fullFuzzySystem.RulesDatabaseSet[0]); } //Parallel.For(1, (currentConf.Особей_в_популяции - 1), i => for (int i = 1; i < currentConf.GENCPopulationSize; i++) { double[] tempMassive = new double[populationMassive[i].Weigths.Count()]; //Parallel.For(0, (populationMassive[i].all_conq_of_rules.Count() - 1), j => for (int j = 0; j < populationMassive[i].Weigths.Count(); j++) { tempMassive[j] = initFunc(populationMassive[i].Weigths[j], currentConf.GENCScateDeverceInit, fullFuzzySystem.LearnSamplesSet.OutputAttribute.Max, fullFuzzySystem.LearnSamplesSet.OutputAttribute.Min); } populationMassive[i].Weigths = tempMassive; //}); for (int j = 0; j < populationMassive[i].TermsSet.Count; j++) //Parallel.For(0, populationMassive[i].TermsSet.Count, j => { tempMassive = populationMassive[i].TermsSet[j].Parametrs.Clone() as double[]; for (int u = 0; u < populationMassive[i].TermsSet[j].Parametrs.Count(); u++) //Parallel.For(0, populationMassive[i].TermsSet[j].Parametrs.Count(), u => { tempMassive[u] = initFunc(tempMassive[u], currentConf.GENCScateDeverceInit, fullFuzzySystem.LearnSamplesSet.InputAttributes [populationMassive[i].TermsSet[j].NumVar].Max, fullFuzzySystem.LearnSamplesSet.InputAttributes[populationMassive[i].TermsSet[j].NumVar].Min); // result.LearnSamplesSet.InputAttributeMax(fuzzyRulesDatabaseMassive[i].TermsSet[j].Max) // fuzzyRulesDatabaseMassive[i].TermsSet[j] .Parametrs[u] //}); } populationMassive[i].TermsSet[j].Parametrs = tempMassive; } //}); } //}); }
public void init_first(KnowlegeBasePCRules base_rule, Random rand, FuzzySystem.FuzzyAbstract.learn_algorithm.conf.ESConfig.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); }
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classifier, ILearnAlgorithmConf config) { start_add_rules = Classifier.RulesDatabaseSet.Count; PCFuzzySystem result = Classifier; if (result.RulesDatabaseSet.Count == 0) { throw new System.FormatException("Что то не то с входными данными"); } OptimizeRullesShrinkConf Config = config as OptimizeRullesShrinkConf; Request_shrink_Rule = Config.ORSCCountShrinkRules; int count_of_swith_off = Request_shrink_Rule; List <byte> Varians_of_run_system = new List <byte>(); for (int i = 0; i < Classifier.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++) { KnowlegeBasePCRules temp_rules = new KnowlegeBasePCRules(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.ErrorLearnSamples(result.RulesDatabaseSet[start_add_rules + i])); } int best_index = errors_of_systems.IndexOf(errors_of_systems.Min()); KnowlegeBasePCRules best = result.RulesDatabaseSet[start_add_rules + best_index]; result.RulesDatabaseSet.Clear(); result.RulesDatabaseSet.Add(best); Console.WriteLine(Pull_of_systems.Count()); result.RulesDatabaseSet[0].TermsSet.Trim(); // result.UnlaidProtectionFix(); return(result); }
/// <summary> /// Step 1 /// </summary> /// <param name="Classifier"></param> /// <param name="config"></param> protected virtual void init(PCFuzzySystem Classifier, ACOSearchConf config) { ACO_iterationCount = config.ACOCountIteration; ACO_antCount = config.ACOCountAnt; ACO_decisionArchiveCount = config.ACODescisionArchiveSize; ACO_q = config.ACOQ; ACO_xi = config.ACOXi; result = Classifier; colonyCount = result.RulesDatabaseSet[0].TermsSet.Count; colonyList = new List <Colony>(); newSolution = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]); basePrecission = result.ClassifyLearnSamples(newSolution); }
//расчитыавем значение X с крышкой public KnowlegeBasePCRules CalcXroof(KnowlegeBasePCRules xi, KnowlegeBasePCRules xj) { var Xroof = new KnowlegeBasePCRules(xi); for (int t = 0; t < Xroof.TermsSet.Count; t++) { for (int p = 0; p < Xroof.TermsSet[t].CountParams; p++) { Xroof.TermsSet[t].Parametrs[p] = (xj.TermsSet[t].Parametrs[p] - xi.TermsSet[t].Parametrs[p]) / (Math.Sqrt(Math.Pow((xj.TermsSet[t].Parametrs[p] - xi.TermsSet[t].Parametrs[p]), 2) + Math.Pow((xi.TermsSet[t].Parametrs[p] - xj.TermsSet[t].Parametrs[p]), 2)) + e); } } return(Xroof); }
public void fullCrossover() { // childrenMassive = new KnowlegeBaseSARules[currentConf.Количество_генерируемых_потомков]; //Parallel.For(0, currentConf.Количество_генерируемых_потомков, i => for (int i = 0; i < currentConf.GENCCountChild; i++) { int a = allRandom.Next(populationMassive.Count()); int b = allRandom.Next(populationMassive.Count()); childrenMassive[i] = new KnowlegeBasePCRules(crossoverFunc(populationMassive[a], populationMassive[b])); } //}); }
private void SetRoles() { HeadLeader = Population[0]; for (int i = 1; i <= numberOfLocalLeaders; i++) { LocalLeaders[i - 1] = Population[i]; } for (int i = numberOfAllParts - numberOfAimlessParts; i < numberOfAllParts; i++) { AimlessParticles[i - numberOfAllParts + numberOfAimlessParts] = Population[i]; } for (int i = numberOfLocalLeaders + 1; i < numberOfAllParts - numberOfAimlessParts; i++) { ExplorerParticles[i - numberOfLocalLeaders - 1] = Population[i]; } }