public void GetDots(SAFuzzySystem approx, KnowlegeBaseSARules 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 SAFuzzySystem(samples, samples);
var usedRules = GetRules(knowlegeBase);
system.RulesDatabaseSet.Add(new KnowlegeBaseSARules(knowlegeBase, null));
}
protected static void writeAboutRules(XmlWriter writer, SAFuzzySystem Approximate)
{
writer.WriteStartElement("Rules");
writer.WriteAttributeString("Count", XmlConvert.ToString(Approximate.RulesDatabaseSet[0].RulesDatabase.Count));
foreach (SARule rule in Approximate.RulesDatabaseSet[0].RulesDatabase)
{
writer.WriteStartElement("Rule");
writer.WriteStartElement("Antecedent");
writer.WriteAttributeString("Count", XmlConvert.ToString(rule.ListTermsInRule.Count));
foreach (Term term in rule.ListTermsInRule)
{
writer.WriteStartElement("Pair");
writer.WriteAttributeString("Variable", Approximate.LearnSamplesSet.InputAttributes[term.NumVar].Name);
writer.WriteAttributeString("Term", XmlConvert.ToString(Approximate.RulesDatabaseSet[0].TermsSet.IndexOf(term)));
writer.WriteEndElement();
}
writer.WriteEndElement();
writer.WriteStartElement("Consequent");
writer.WriteAttributeString("Value", XmlConvert.ToString(rule.IndependentConstantConsequent));
writer.WriteEndElement();
writer.WriteEndElement();
}
writer.WriteEndElement();
}
protected static void writeAboutVariblesAndTerms(XmlWriter writer, SAFuzzySystem Approximate)
{
writer.WriteStartElement("Variables");
writer.WriteAttributeString("Count", XmlConvert.ToString(Approximate.CountFeatures));
for (int i = 0; i < Approximate.CountFeatures; i++)
{
if (Approximate.AcceptedFeatures[i] == false)
{
continue;
}
writer.WriteStartElement("Variable");
writer.WriteAttributeString("Name", Approximate.LearnSamplesSet.InputAttributes[i].Name);
writer.WriteAttributeString("Min",
XmlConvert.ToString(Approximate.LearnSamplesSet.InputAttributes[i].Min));
writer.WriteAttributeString("Max",
XmlConvert.ToString(Approximate.LearnSamplesSet.InputAttributes[i].Max));
List <Term> terms_for_varrible =
Approximate.RulesDatabaseSet[0].TermsSet.Where(x => x.NumVar == i).ToList();
writer.WriteStartElement("Terms");
writer.WriteAttributeString("Count", XmlConvert.ToString(terms_for_varrible.Count));
foreach (var term in terms_for_varrible)
{
BaseUFSWriter.writeAboutTerm(writer, Approximate.RulesDatabaseSet[0].TermsSet.IndexOf(term), term);
}
writer.WriteEndElement();
writer.WriteEndElement();
}
writer.WriteEndElement();
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approximate, ILearnAlgorithmConf conf)
{
BacteryAlgorithmConfig Config = conf as BacteryAlgorithmConfig;
sendBactery = Config.BFOCountSolution;
interPSOtoSend = Config.BFOCountIteration;
result = Approximate;
if (result.RulesDatabaseSet.Count < 1)
{
throw new InvalidDataException("Нечеткая система не проинициализированна");
}
KnowlegeBaseSARules backSave = new KnowlegeBaseSARules(result.RulesDatabaseSet[0]);
double backResult = result.approxLearnSamples(result.RulesDatabaseSet[0]);
savetoUFS(result.RulesDatabaseSet, 0, 0, 0);
BacteryRunner();
KnowlegeBaseSARules[] solutions = loadDatabase();
solutions = sortSolution(solutions);
if (solutions.Count() < 1)
{
result.RulesDatabaseSet[0] = backSave; return(result);
}
result.RulesDatabaseSet[0] = solutions[0];
double newResult = result.approxLearnSamples(result.RulesDatabaseSet[0]);
if (newResult > backResult)
{
result.RulesDatabaseSet[0] = backSave;
}
result.RulesDatabaseSet[0].TermsSet.Trim();
return(result);
}
public override SAFuzzySystem Generate(FuzzySystem.SingletoneApproximate.SAFuzzySystem Approximate, IGeneratorConf config)
{
SAFuzzySystem result = Approximate;
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 < 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(Approximate, 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());
GC.Collect();
// result.UnlaidProtectionFix();
result.RulesDatabaseSet[0].TermsSet.Trim();
return(result);
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approx, ILearnAlgorithmConf conf)
{
SAFuzzySystem result = Approx;
double minValue = 5;
int minFeature = 0;
int minATerm = 0;
int minBTerm = 1;
int indexDatabase = 0;
for (int i = 0; i < result.CountFeatures; i++)
{
List <Term> soureceByFeature = result.RulesDatabaseSet[indexDatabase].TermsSet.Where(x => x.NumVar == i).ToList();
for (int j = 0; j < soureceByFeature.Count(); j++)
{
for (int k = j + 1; k < soureceByFeature.Count(); k++)
{
double temp = TermOnterpreting.getIndexByLinds(soureceByFeature[j], soureceByFeature[k], soureceByFeature);
if (temp < minValue)
{
minValue = temp;
minATerm = j;
minBTerm = k;
minFeature = i;
}
}
}
}
result = BreakCrossTerm(result, minFeature, minATerm, minBTerm, indexDatabase);
result.RulesDatabaseSet[0].TermsSet.Trim();
return(result);
}
public static SAFuzzySystem loadUFS(this SAFuzzySystem Approx, string fileName)
{
XmlDocument Source = new XmlDocument();
Source.Load(fileName);
return(Approx.loadUFS(Source));
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approx, ILearnAlgorithmConf conf)
{
SAFuzzySystem result = Approx;
BeeParamsConf Config = conf as BeeParamsConf;
Init(Config);
theFuzzySystem = result;
if (result.RulesDatabaseSet.Count < 1)
{
throw (new Exception("Что то не так с базой правил"));
}
theHive = new HiveParams(this, result.RulesDatabaseSet[0]);
// HiveParams theHive = new ParallelHiveParams(this, result.RulesDatabaseSet[0]);
// HiveParams theHive = new HiveParallelParams2(this, result.RulesDatabaseSet[0]);
theBest = new BeeParams(result.RulesDatabaseSet[0], this);
double temperature = initTemp;
for (int r = 0; r < iterration; r++)
{
temperature = oneIterate(temperature);
GC.Collect();
}
theBest = lastStep(theBest);
Approx.RulesDatabaseSet[0] = theBest.PositionOfBee;
Approx.RulesDatabaseSet[0].TermsSet.Trim();
return(Approx);
}
public override int Run(string[] args)
{
Console.WriteLine("Start");
fill_params(args);
Console.WriteLine("Params get \nfile in {0} \n", file_in);
Approx_learn_set = BaseUFSLoader.LoadLearnFromUFS(file_in);
Console.WriteLine("Tra load");
Approx_test_set = BaseUFSLoader.LoadTestFromUFS(file_in);
Console.WriteLine("Tst load");
conf = new PSOBacterySearchConf();
conf.Init(Approx_learn_set.CountVars);
conf.loadParams(confParams);
Console.WriteLine("Conf Filed");
Approx_Singletone = new SAFuzzySystem(Approx_learn_set, Approx_test_set);
Approx_Singletone = SAFSUFSLoader.loadUFS(Approx_Singletone, file_in);
Console.WriteLine("Classifier created");
optimaze = new PSOMethods.Approx.Term_config_PSO_Bactery();
Approx_Singletone = optimaze.TuneUpFuzzySystem(Approx_Singletone, conf);
Console.WriteLine("Optimization complite");
SAFSUFSWriter.saveToUFS(Approx_Singletone, file_out);
Console.WriteLine("Saved");
return(1);
}
public virtual void oneIterate(SAFuzzySystem result)
{
foreach (Colony colony in colonyList) //Шаг 9. Если имеется следующая колония, то сделать текущим первого муравья в этой колонии и перейти на шаг 5, иначе перейти на шаг 10.
{
for (int i = 0; i < ACO_antCount; i++) //Шаг 8. Если в текущей колонии имеется следующий муравей, то сделать его текущим и перейти к шагу 5, иначе перейти на шаг 9.
{
// Шаг 5. Для текущего муравья текущей колонии вычислить номер l, используемой функции Гаусса по формуле 2.14. Определить l i для i = 1, ..., N по формуле 2.15. Сгенерировать N случайных величин {θl*1, θl*2,…, θl*N} на основе полученных функций gl i(x).
colony.runAnt(i, rand, ACO_xi);
//Шаг 6. Найти ошибку вывода нечеткой системы при параметрах {θ1,…, θN }, если ошибка меньше текущей, то сохранить новые параметры.
baseError = colony.checkAntDecision(i, baseError);
// Шаг 7. Добавить в архив новое решение, ранжировать архив, удалить из архива худшее решение.
colony.updateDecisionArchive(i);
}
}
// Шаг. * Модифицированный алгоритм. Проверяем находиться ли в экстремуме алгоритм.
if (isInExtremum())
{
foreach (Colony colony in colonyList) //Шаг **. Обновляем архивы, заполняем их случайными решениями и элитными
{
colony.refillDesicionArchive(MACOCountEliteDecision - 1, rand, this);
}
}
}
public static double getGISSumReverce(this SAFuzzySystem source, double goodsForArea = 0, int indexDataBase = 0)
{
double result = 0.0;
if (goodsForArea == 0)
{
goodsForArea = FuzzyCore.Properties.Settings.Default.Pareto_simpler_UnionTerms_bySqarePercent * 0.01;
}
if (source != null)
{
double temp = 0.0;
for (int i = 0; i < source.CountFeatures; i++)
{
temp = 0.0;
List <Term> termList = source.RulesDatabaseSet[indexDataBase].TermsSet.Where(x => x.NumVar == i).ToList();
if (termList.Count() <= 1)
{
temp = 0.0;
}
else
{
for (int j = 0; j < termList.Count; j++)
{
for (int k = j + 1; k < termList.Count; k++)
{
temp += 1 - TermOnterpreting.getIndexByAreaTerms(termList[j], termList[k], goodsForArea);
}
}
}
result += temp;
}
result = result / (double)source.CountFeatures;
}
return(result);
}
private SAFuzzySystem BreakCrossTerm(SAFuzzySystem Approx, int Feature, int indexATerm, int indexBterm, int dataBase)
{
SAFuzzySystem result = Approx;
KnowlegeBaseSARules 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);
}
public SAFuzzySystem TuneUpFuzzySystem(SingletonHybride Ocean, SAFuzzySystem Approximate, ILearnAlgorithmConf conf)
{
HybrideOcean = Ocean;
base.TuneUpFuzzySystem(Approximate, conf);
Ocean.Store(chooseDiscovers(1), this.ToString());
return(result);
}
public static double getGICSumReverce(this SAFuzzySystem source, int indexDataBase = 0)
{
double result = 0.0;
if (source != null)
{
double temp = 0.0;
for (int i = 0; i < source.CountFeatures; i++)
{
temp = 0.0;
List <Term> termList = source.RulesDatabaseSet[indexDataBase].TermsSet.Where(x => x.NumVar == i).ToList();
if (termList.Count() <= 1)
{
temp = 0.0;
}
else
{
for (int j = 0; j < termList.Count; j++)
{
for (int k = j + 1; k < termList.Count; k++)
{
temp += 1.0 - TermOnterpreting.getIndexByCentersClose(termList[j], termList[k], termList.Count(), source.LearnSamplesSet.InputAttributes[i].Scatter);
}
}
}
result += temp;
}
result = result / (double)source.CountFeatures;
}
return(result);
}
public override FuzzySystem.SingletoneApproximate.SAFuzzySystem TuneUpFuzzySystem(FuzzySystem.SingletoneApproximate.SAFuzzySystem Approximate, ILearnAlgorithmConf conf)
{
result = Approximate;
Init(conf);
Ocean = new SingletonHybride(new SAFuzzySystem(result));
List <Task> AlgTasks = new List <Task>();
Parallel.For(0, Configs.Count, magic =>
{
Task CurrentTask = new Task(() => { Algorithms[magic].TuneUpFuzzySystem(Ocean, new SAFuzzySystem(result), Configs[magic]); });
AlgTasks.Add(CurrentTask);
AlgTasks[magic].Start();
}
);
Task.WaitAll(AlgTasks.ToArray());
List <KnowlegeBaseSARules> ListSystems = Ocean.Get(1, FuzzySystem.FuzzyAbstract.Hybride.FuzzyHybrideBase.goodness.best, FuzzySystem.FuzzyAbstract.Hybride.FuzzyHybrideBase.islandStrategy.All);
ListSystems.Add(result.RulesDatabaseSet[0]);
result.RulesDatabaseSet[0] = ListSystems.SelectBest(result, 1)[0];
result.RulesDatabaseSet[0].TermsSet.Trim();
return(result);
}
public double Calc_Error(SAFuzzySystem error_checker)
{
Individ temp_Best = null;
double min_error = double.PositiveInfinity;
foreach (Individ indiv in the_popualate)
{
indiv.calc_Error(error_checker);
if (min_error > indiv.error)
{
min_error = indiv.error;
temp_Best = indiv;
}
}
if (temp_Best != null)
{
if (best_individ != null)
{
if (temp_Best.error > best_individ.error)
{
best_individ = temp_Best;
}
}
else
{
best_individ = temp_Best;
}
}
return(min_error);
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
Init(conf);
KnowlegeBaseSARules temp_c_Rule = new KnowlegeBaseSARules(Classifier.RulesDatabaseSet[0]);
SAFuzzySystem result = Classifier;
for (int t = 0; t < population_count; t++)
{
monkey[t] = new KnowlegeBaseSARules(result.RulesDatabaseSet[0]);
for (int k = 0; k < result.RulesDatabaseSet[0].TermsSet.Count; k++)
{
for (int q = 0; q < result.RulesDatabaseSet[0].TermsSet[k].CountParams; q++)
{
//monkey[t].TermsSet[k].Parametrs[q] = StaticRandom.NextDouble() * (result.RulesDatabaseSet[0].TermsSet[k].Max - result.RulesDatabaseSet[0].TermsSet[k].Min);
monkey[t].TermsSet[k].Parametrs[q] = GaussRandom.Random_gaussian(rand, monkey[t].TermsSet[k].Parametrs[q], monkey[t].TermsSet[k].Parametrs[q] * 0.05);
}
}
result.UnlaidProtectionFix(monkey[t]);
// delete
testvals[t] = result.ErrorLearnSamples(monkey[t]);
Console.WriteLine("Begin: " + t.ToString() + " " + iter.ToString() + " " + testvals[t].ToString());
}
bestsolution = new KnowlegeBaseSARules(monkey.SelectBest(result, 1)[0]);
bestsolutionnumber = result.ErrorLearnSamples(bestsolution);
iter_amount = somersault_iter * (1 + jump_iter * (1 + crawl_iter));
deltaLength = result.RulesDatabaseSet[0].TermsSet.Sum(x => x.Parametrs.Length);
for (int r = 0; r < somersault_iter; r++)
{
for (int t = 0; t < jump_iter; t++)
{
for (int e = 0; e < crawl_iter; e++)
{
iter++;
CheckForBest(result);
oneClimb(result, deltaLength, step);
//Console.WriteLine(iter_amount.ToString() + "/" + iter.ToString());
}
iter++;
oneWatchJump(result);
//Console.WriteLine(iter_amount.ToString() + "/" + iter.ToString());
}
iter++;
oneGlobalJump(result);
Console.WriteLine(iter_amount.ToString() + "/" + iter.ToString());
}
/* for (int t = 0; t < population_count; t++)
* if (result.ErrorLearnSamples(monkey[best]) < result.ErrorLearnSamples(monkey[t]))
* best = t; */
CheckForBest(result);
if (bestsolutionnumber < result.ErrorLearnSamples(result.RulesDatabaseSet[0]))
{
result.RulesDatabaseSet[0] = bestsolution;
}
iter = 0;
return(result);
}
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 static double getLindisSumReverse(this SAFuzzySystem source, int indexDataBase = 0)
{
double result = 0.0;
if (source != null)
{
double temp = 0.0;
for (int i = 0; i < source.CountFeatures; i++)
{
temp = 0.0;
List <Term> termList = source.RulesDatabaseSet[indexDataBase].TermsSet.Where(x => x.NumVar == i).ToList();
if (termList.Count() <= 1)
{
temp = 0.0;
}
else
{
for (int j = 0; j < termList.Count; j++)
{
for (int k = j + 1; k < termList.Count; k++)
{
temp += 1 - TermOnterpreting.getIndexByLinds(termList[j], termList[k], termList);
}
}
}
result += temp;
}
result = result / (double)source.CountFeatures;
}
return(result);
}
public virtual void Init(ILearnAlgorithmConf conf)
{
currentConf = conf as GeneticConf;
fullFuzzySystem = result;
step = 0;
errorAfter = 0;
errorBefore = result.approxLearnSamples(result.RulesDatabaseSet[0]);
backUp = result.RulesDatabaseSet[0];
initFunc = new initFuncType(localInit);
if (currentConf.GENCTypeInit == GeneticConf.Alg_Init_Type.Глобальный)
{
initFunc = new initFuncType(globalInit);
}
crossoverFunc = new crossoverFuncType(unifiedCrossover);
if (currentConf.GENCTypeCrossover == GeneticConf.Alg_Crossover_Type.Многоточечный)
{
crossoverFunc = new crossoverFuncType(pointsCrossover);
}
selectionFunc = new selectionFuncType(rouletteSelection);
if (currentConf.GENCTypeSelection == GeneticConf.Alg_Selection_Type.Случайный)
{
selectionFunc = new selectionFuncType(randomSelection);
}
if (currentConf.GENCTypeSelection == GeneticConf.Alg_Selection_Type.Элитарный)
{
selectionFunc = new selectionFuncType(eliteSelection);
}
fullInit(); // Здесь проходит инициализация
}
public override int Run(string[] args)
{
Console.WriteLine("Start");
fill_params(args);
Console.WriteLine("Params get \nfile in {0} \n", file_in);
Approx_learn_set = BaseUFSLoader.LoadLearnFromUFS(file_in);
Console.WriteLine("Tra load");
Approx_test_set = BaseUFSLoader.LoadTestFromUFS(file_in);
Console.WriteLine("Tst load");
conf = new MultiGoalOptimaze_conf();
conf.Init(Approx_learn_set.CountVars);
conf.loadParams(confParams);
Console.WriteLine("Conf Filed");
Approx_Singletone = new SAFuzzySystem(Approx_learn_set, Approx_test_set);
Approx_Singletone = SAFSUFSLoader.loadUFS(Approx_Singletone, file_in);
Console.WriteLine("Classifier created");
optimaze = new MultiGoalOpimize();
Approx_Singletone = optimaze.TuneUpFuzzySystem(Approx_Singletone, conf);
Console.WriteLine("Optimization complite");
// a_FS_UFS.saveToUFS(Class_Pittsburg, file_out);
Console.WriteLine("Saved");
return(1);
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approx, ILearnAlgorithmConf conf)
{
try
{
ACOSearchConf config = conf as ACOSearchConf;
if (preCheck(Approx) == false)
{
throw new ArgumentNullException("Не правильно инициализированная нечеткая система");
}
// Шаг 1. Задать начальные параметры.
init(Approx, config);
// Шаг 2. Сгенерировать популяцию муравьев в колониях
colonyGenerate();
Parallel.ForEach(colonyList, colony =>
{
// Шаг 3. Сгенерировать k случайных решений, для всех архивов решений с последующим оцениванием и ранжированием.
randomDecisionsGenerate(colony);
//Шаг 4. Найти значения вектора весов.
calc_decisions_Weight(colony);
}
);
for (int iterNum = 0; iterNum < ACO_iterationCount; iterNum++)
{
foreach (Colony colony in colonyList) //Шаг 9. Если имеется следующая колония, то сделать текущим первого муравья в этой колонии и перейти на шаг 5, иначе перейти на шаг 10.
{
for (int i = 0; i < ACO_antCount; i++) //Шаг 8. Если в текущей колонии имеется следующий муравей, то сделать его текущим и перейти к шагу 5, иначе перейти на шаг 9.
{
// Шаг 5. Для текущего муравья текущей колонии вычислить номер l, используемой функции Гаусса по формуле 2.14. Определить l i для i = 1, ..., N по формуле 2.15. Сгенерировать N случайных величин {θl*1, θl*2,…, θl*N} на основе полученных функций gl i(x).
colony.runAnt(i, rand, ACO_xi);
//Шаг 6. Найти ошибку вывода нечеткой системы при параметрах {θ1,…, θN }, если ошибка меньше текущей, то сохранить новые параметры.
baseError = colony.checkAntDecision(i, baseError);
// Шаг 7. Добавить в архив новое решение, ранжировать архив, удалить из архива худшее решение.
colony.updateDecisionArchive(i);
}
}
}
prepareFinalFuzzySystem();
result.RulesDatabaseSet[0].TermsSet.Trim();
return(result);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public SAFuzzySystem TuneUpFuzzySystem(SingletonHybride Ocean, SAFuzzySystem Approximate, ILearnAlgorithmConf conf)
{
HybrideOcean = Ocean;
base.TuneUpFuzzySystem(Approximate, conf);
Ocean.Store(chooseDiscovers(1), this.ToString());
theFuzzySystem.RulesDatabaseSet[0].TermsSet.Trim();
return(theFuzzySystem);
}
public region2(List <region_side> sides, SAFuzzySystem approx, List <input_space> variable_spaces)
{
this.sides = new List <region_side>(sides.Count);
this.sides.AddRange(sides);
this.approx = approx;
get_dots(approx.LearnSamplesSet.DataRows);
this.variable_spaces = variable_spaces;
}
public override SAFuzzySystem Generate(FuzzySystem.SingletoneApproximate.SAFuzzySystem Approximate, IGeneratorConf config)
{
start_add_rules = Approximate.RulesDatabaseSet.Count;
SAFuzzySystem 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++)
{
KnowlegeBaseSARules temp_rules = new KnowlegeBaseSARules(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());
KnowlegeBaseSARules 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 oneIterate(SAFuzzySystem result)
{
fullCrossover(); // здесь проходит скрещивание
mutationAlg(); // здесь проходит мутация
fullSelection(); //здесь проходит селекция
step = findMinErrorElement(); // поиск лучшей базы знаний
result.RulesDatabaseSet[0] = new KnowlegeBaseSARules(result.RulesDatabaseSet[step]);
result.RulesDatabaseSet.RemoveRange(1, (result.RulesDatabaseSet.Count - 1));
}
public Graph(List <int>[] childNodes, SAFuzzySystem source)
{
this.childNodes = childNodes;
islands = new List <Island>();
for (int i = 0; i < childNodes.Length; i++)
{
islands.Add(new Island(source));
}
}
public override SAFuzzySystem TuneUpFuzzySystem(FuzzySystem.SingletoneApproximate.SAFuzzySystem Approximate, ILearnAlgorithmConf config)
{
SAFuzzySystem 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 RecombineUFSApproximate(string UFSPAth)
: base(UFSPAth)
{
SampleSet LearnTable = BaseUFSLoader.LoadLearnFromUFS(Source);
SampleSet TestTable = BaseUFSLoader.LoadTestFromUFS(Source);
fuzzy_system = new SAFuzzySystem(LearnTable, TestTable);
fuzzy_system = fuzzy_system.loadUFS(Source);
}
public Graph(int size, SAFuzzySystem source)
{
childNodes = new List <int> [size];
islands = new List <Island>();
for (int i = 0; i < size; i++)
{
childNodes[i] = new List <int>();
islands.Add(new Island(source));
}
}
