public override TSAFuzzySystem TuneUpFuzzySystem(TSAFuzzySystem Approximate, ILearnAlgorithmConf Conf)
{
result = Approximate;
List <int[]> groups = new List <int[]>();
Init(Conf);
SetPopulation();
Population = SortRules(Population);
NS = new int[Nsr];
NS = SetNS(Population, Nsr);
groups = GroupStream();
double BestMSETest = result.RMSEtoMSEforTest(result.approxTestSamples(Population[0]));
double BestMSELearn = result.RMSEtoMSEforLearn(result.approxLearnSamples(Population[0]));
int BestIter = 0;
for (int i = 1; i <= MaxIter; i++)
{
Console.WriteLine(i + " - Итерация");
Population = SetNextPosition(groups, Population);
Population = Replacement(groups, Population);
if (flag)
{
Evaporation(groups.Last());//Испарение
}
if (BestMSETest > result.RMSEtoMSEforTest(result.approxTestSamples(Population[0])))
{
BestMSETest = result.RMSEtoMSEforTest(result.approxTestSamples(Population[0]));
BestMSELearn = result.RMSEtoMSEforLearn(result.approxLearnSamples(Population[0]));
BestIter = i;
}
}
Console.WriteLine(ToString(true));
Console.WriteLine("Итер - " + BestIter + " MSET - " + BestMSETest + " MSEL - " + BestMSELearn);
result.RulesDatabaseSet[0] = Population[0];
return(result);
}
public override FuzzySystem.PittsburghClassifier.PCFuzzySystem TuneUpFuzzySystem(FuzzySystem.PittsburghClassifier.PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
result = Classifier;
Init(conf);
//OneIteration
for (int i = 0; i < count_iteration; i++)
{
oneIterate(result);
}
Final();
return(result);
}
//основные вычисления
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classify, ILearnAlgorithmConf conf)
{
result = Classify;
rand = new Random();
Init(conf);
SetPopulation();
bool[] BEST = result.AcceptedFeatures;
double bestError = result.ErrorLearnSamples(result.RulesDatabaseSet[0]);
//отчистка консоли
Dictionary <bool[], double> PopulationWithAccuracy = new Dictionary <bool[], double>();
double accuracy = 0;
//запуск итераций
for (int it = 0; it < iter; it++)
{
//расчитыавем значение фитнес-функции
for (int i = 0; i < Population.Count; i++)
{
result.AcceptedFeatures = Population[i];
accuracy = result.ErrorLearnSamples(result.RulesDatabaseSet[0]);
PopulationWithAccuracy.Add(Population[i], accuracy);
}
Population.Clear();
foreach (var pair in PopulationWithAccuracy.OrderByDescending(pair => pair.Value))
{
Population.Add(pair.Key);
}
PopulationWithAccuracy.Clear();
double[] K = new double[Population.Count];
double sumK = 0;
double avK = 0;
for (int i = 0; i < Population.Count; i++)
{
result.AcceptedFeatures = Population[i];
K[i] = result.ErrorLearnSamples(result.RulesDatabaseSet[0]);
sumK += K[i];
}
avK = sumK / K.Length;
bool[] KDis = new bool[result.CountFeatures];
for (int i = 0; i < KDis.Length; i++)
{
if (rand.Next(0, 2) == 0)
{
KDis[i] = false;
}
else
{
KDis[i] = true;
}
}
//перебрать значения фитнес функции
//расчитыавем значение D
double dit;
dit = it;
double diter;
diter = iter;
bool D = true;
//расчитыавем значение Xfood
var Xfood = new bool[result.CountFeatures];
for (int t = 0; t < Xfood.Length; t++)
{
Xfood[t] = false;
for (int i = 0; i < Population.Count; i++)
{
Xfood[t] = merge(Population[i][t], KDis[t]);
}
}
//расчитываем значение Cfood
double Cfood = 2 * (1 - (dit / diter));
bool CDisfood;
if (Cfood <= 1)
{
CDisfood = false;
}
else
{
CDisfood = true;
}
//расчитываем значение Bfood
List <bool[]> Bfood = new List <bool[]>(Population.Count);
for (int i = 0; i < Population.Count; i++)
{
Bfood.Add(new bool[Population[i].Length]);
if (rand.Next(0, 2) == 0)
{
Kroofifood = false;
}
else
{
Kroofifood = true;
}
for (int t = 0; t < Bfood[i].Length; t++)
{
Bfood[i][t] = merge(merge(CDisfood, Kroofifood), Xfood[t]);
}
}
//расчитываем значение Bbest
List <bool[]> Bbest = new List <bool[]>(Population.Count);
for (int i = 0; i < Population.Count; i++)
{
Bbest.Add(new bool[Population[i].Length]);
if (rand.Next(0, 2) == 0)
{
Kroofifood = false;
}
else
{
Kroofifood = true;
}
for (int t = 0; t < Bbest[i].Length; t++)
{
Bbest[i][t] = merge(Kroofifood, Xfood[t]);
}
}
//расчитываем значение B
List <bool[]> B = new List <bool[]>(Population.Count);
for (int i = 0; i < Population.Count; i++)
{
B.Add(new bool[Population[i].Length]);
for (int t = 0; t < B[i].Length; t++)
{
B[i][t] = merge(Bfood[i][t], Bbest[i][t]);
}
}
//расчитываем значение F
List <bool[]> F = new List <bool[]>(Population.Count);
for (int i = 0; i < Population.Count; i++)
{
if (i == 0)
{
F.Add(new bool[Population[i].Length]);
for (int t = 0; t < F[i].Length; t++)
{
F[i][t] = merge(true, B[i][t]);
}
}
else
{
F.Add(new bool[Population[i].Length]);
for (int t = 0; t < F[i].Length; t++)
{
F[i][t] = merge(merge(true, B[i][t]), merge(false, F[i - 1][t]));
}
}
}
List <int>[] neihbors = new List <int> [Population.Count];
//расчитываем значение alocal
List <bool[]> alocal = new List <bool[]>(Population.Count);
for (int i = 0; i < Population.Count; i++)
{
alocal.Add(new bool[Population[i].Length]);
neihbors[i] = countneihbors(Population[i]);
for (int t = 0; t < alocal[i].Length; t++)
{
alocal[i][t] = false;
for (int j = 0; j < neihbors[i].Count; j++)
{
bool KRoofij = merge(KDis[t], Population[neihbors[i][j]][t]);
bool[] XRoofij = new bool[Population.Count];
XRoofij = CalcXroof(Population[i], Population[neihbors[i][j]]);
alocal[i][t] = merge(KRoofij, XRoofij[t]);
}
}
}
//расчитываем значение Cbest
bool Cbest;
if (rand.Next(0, 2) == 0)
{
Cbest = false;
}
else
{
Cbest = true;
}
//расчитываем значение atarget
List <bool[]> atarget = new List <bool[]>(Population.Count);
for (int i = 0; i < Population.Count; i++)
{
atarget.Add(new bool[Population[i].Length]);
bool[] XRoofibest = new bool[Population.Count];
XRoofibest = CalcXroof(Population[i], Population[0]);
for (int t = 0; t < alocal[i].Length; t++)
{
bool KRoofibest = KDis[t];
atarget[i][t] = merge(merge(Cbest, KRoofibest), XRoofibest[t]);
}
}
//расчитываем значение a
List <bool[]> a = new List <bool[]>(Population.Count);
for (int i = 0; i < Population.Count; i++)
{
a.Add(new bool[Population[i].Length]);
for (int t = 0; t < a[i].Length; t++)
{
a[i][t] = merge(atarget[i][t], alocal[i][t]);
}
}
//расчитываем значение N
List <bool[]> N = new List <bool[]>(Population.Count);
for (int i = 0; i < Population.Count; i++)
{
if (i == 0)
{
N.Add(new bool[Population[i].Length]);
for (int t = 0; t < N[i].Length; t++)
{
N[i][t] = merge(true, a[i][t]);
}
}
else
{
N.Add(new bool[Population[i].Length]);
for (int t = 0; t < F[i].Length; t++)
{
N[i][t] = merge(a[i][t], N[i - 1][t]);
}
}
}
//расчитываем значение dX
List <bool[]> dX = new List <bool[]>(Population.Count);
for (int i = 0; i < Population.Count; i++)
{
dX.Add(new bool[Population[i].Length]);
for (int t = 0; t < a[i].Length; t++)
{
dX[i][t] = merge(merge(F[i][t], N[i][t]), D);
}
}
//выводим значение BEST
// Console.Write("Значение BEST_ = ");
// Console.WriteLine(BEST);
//расчитываем значение X(t+dt)
for (int i = 0; i < Population.Count; i++)
{
Population[i] = new bool[Population[i].Length];
for (int t = 0; t < Population[i].Length; t++)
{
Population[i][t] = merge(Population[i][t], dX[i][t]);
}
}
for (int i = 0; i < Population.Count; i++)
{
result.AcceptedFeatures = Population[i];
double temp = result.ErrorLearnSamples(result.RulesDatabaseSet[0]);
if (temp < bestError)
{
BEST = Population[i];
bestError = temp;
}
}
double y = it;
if (y % 10 == 0 & y != 0)
{
Console.WriteLine(it);
Console.WriteLine(bestError);
}
}
result.AcceptedFeatures = BEST;
for (int i = 0; i < result.AcceptedFeatures.Length; i++)
{
if (result.AcceptedFeatures[i] == false)
{
Console.Write("0 ");
}
else
{
Console.Write("1 ");
}
}
Console.WriteLine();
Console.WriteLine(result.ErrorLearnSamples(result.RulesDatabaseSet[0]));
Console.WriteLine(result.ErrorTestSamples(result.RulesDatabaseSet[0]));
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem FSystem, ILearnAlgorithmConf conf)
{
isClass = true;
return(UniversalMethod(FSystem, conf) as PCFuzzySystem);
}
public PCFuzzySystem TuneUpFuzzySystem(PittsburgHybride Ocean, PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
HybrideOcean = Ocean;
base.TuneUpFuzzySystem(Classifier, conf);
Ocean.Store(chooseDiscovers(1), this.ToString());
return(fullFuzzySystem);
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approx, ILearnAlgorithmConf conf)
{
iskl_prizn = "";
count_iteration = ((Param)conf).Количество_итераций;
count_populate = ((Param)conf).Число_осколков;
exploration = ((Param)conf).Фактор_исследования;
reduce_koef = ((Param)conf).Уменьшающий_коэффициент;
priznaki_usech = ((Param)conf).Усечённые_признаки;
iter_descrete = ((Param)conf).Итерации_дискр_алг;
int iter = 0, iter2, i, j, count_terms, count_iter = 0;
int count_cons, count_best2 = 0, best_pred = 0;
double RMSE_best, cosFi, RMSE_best2;
int Nd, variables, k = 1, best2 = 0;
SAFuzzySystem result = Approx;
int type = Approx.RulesDatabaseSet[0].TermsSet[0].CountParams;
Nd = Approx.RulesDatabaseSet[0].TermsSet.Count * type;
double[] X_best = new double[Nd + 1];
double[,] X_pred = new double[2, Nd + 1];
double[,] direction = new double[count_populate, Nd + 1];
double[,] d = new double[count_populate, Nd + 1];
double[,] explosion = new double[count_populate, Nd + 1];
double[,] shrapnel = new double[count_populate, Nd + 1];
cosFi = Math.Cos(2 * Math.PI / count_populate);
RMSE_best = Approx.approxLearnSamples(Approx.RulesDatabaseSet[0]);
RMSE_best2 = Approx.approxLearnSamples(Approx.RulesDatabaseSet[0]);
count_cons = Approx.RulesDatabaseSet[0].all_conq_of_rules.Count();
double[] RMSE = new double[count_populate];
double[] RMSE_all = new double[iter];
double[] RMSE_tst = new double[count_populate];
double[] RMSE2 = new double[count_populate];
double[] RMSE_pred = new double[2];
double[] cons_best = new double[count_cons];
variables = Approx.LearnSamplesSet.CountVars;
count_terms = Approx.RulesDatabaseSet[0].TermsSet.Count;
int[] terms = new int[variables];
double[] X_best2 = new double[variables];
double[,] d3 = new double[count_populate, variables];
double[,] priznak = new double[count_populate, variables];
for (i = 0; i < variables; i++)
{
priznak[0, i] = 1;
X_best2[i] = 1;
}
KnowlegeBaseSARules[] X = new KnowlegeBaseSARules[count_populate];
for (int s = 0; s < count_populate - 1; s++)
{
X[s] = new KnowlegeBaseSARules(Approx.RulesDatabaseSet[0]);
Approx.RulesDatabaseSet.Add(X[s]);
}
for (iter2 = 0; iter2 < iter_descrete; iter2++)
{
best2 = 0;
//if (count_best2 < 10)
//{
if (iter == 0)
{
for (k = 0; k < variables; k++)
{
d3[0, k] = RandomNext(Approx.LearnSamplesSet.InputAttributes[k].Min, Approx.LearnSamplesSet.InputAttributes[k].Max);
}
}
for (i = 0; i < variables; i++)
{
for (j = 1; j < count_populate; j++)
{
generate:
d3[j, i] = d3[j - 1, i] * randn();
priznak[j, i] = d3[j, i] * cosFi;
if ((priznak[j, i] < Approx.LearnSamplesSet.InputAttributes[i].Min) || (priznak[j, i] > Approx.LearnSamplesSet.InputAttributes[i].Max))
{
goto generate;
}
Random random = new Random();
if (random.NextDouble() < descret(priznak[j, i]))
{
priznak[j, i] = 1;
}
else
{
priznak[j, i] = 0;
}
}
}
for (j = 1; j < count_populate; j++)
{
for (int h = 0; h < variables; h++)
{
if (priznak[j, h] == 1)
{
Approx.AcceptedFeatures[h] = true;
}
else
{
Approx.AcceptedFeatures[h] = false;
}
}
RMSE2[j] = Approx.approxLearnSamples(Approx.RulesDatabaseSet[0]);
if (RMSE2[j] > RMSE_best2)
{
RMSE_best2 = RMSE2[j];
best2 = j;
}
for (int h = 0; h < variables; h++)
{
X_best2[h] = priznak[best2, h];
}
}
if (best_pred == best2)
{
count_best2++;
}
else
{
count_best2 = 0;
}
for (k = 0; k < variables; k++)
{
priznak[0, k] = priznak[best2, k];
}
count_iter++;
//}
}
for (k = 0; k < variables; k++)
{
if (priznak[best2, k] == 1)
{
Approx.AcceptedFeatures[k] = true;
}
else
{
Approx.AcceptedFeatures[k] = false;
iskl_prizn += (k + 1).ToString() + " ";
}
}
return(result);
}
public override TSAFuzzySystem TuneUpFuzzySystem(TSAFuzzySystem Approx, ILearnAlgorithmConf conf)
// Здесь ведется оптимизация вашим алгоритмом
{
var first = true;
var WeedOriginal = new TSAFuzzySystemWithErrorKnowledgeBase(Approx);
double KLIRange = ((WeedsCut_conf)conf).Граница;
maxiter = ((WeedsCut_conf)conf).Количество_итераций;
var MaxUsingRule = ((WeedsCut_conf)conf).Максимально_потомков;
var MinUsingRule = ((WeedsCut_conf)conf).Минимально_потомков;
Random r = new Random();
while (first || Double.IsNaN((WeedOriginal.RulesDatabaseSet[0] as KnowlegeBaseTSARules).error))
{
int allUsingRuleCount = ((WeedsCut_conf)conf).Начальное_количество;
WeedOriginal = new TSAFuzzySystemWithErrorKnowledgeBase(Approx);
first = false;
List <int> list = new List <int>();
int counter = 0;
for (int i = 0; i < allUsingRuleCount; i++)
{
list.Add(counter);
counter++;
}
for (int i = 0; i < WeedOriginal.AcceptedFeatures.Count(); i++)
{
WeedOriginal.AcceptedFeatures[i] = false;
}
for (int i = 0; i < allUsingRuleCount; i++)
{
int index = r.Next(0, allUsingRuleCount - i);
int ddd = list[index];
WeedOriginal.AcceptedFeatures[ddd] = true;
list.RemoveAt(index);
}
global::KLI.KLI s = new global::KLI.KLI();
WeedOriginal = new TSAFuzzySystemWithErrorKnowledgeBase(s.Generate(WeedOriginal as TSAFuzzySystem, new KLI_conf()
{
MaxValue = KLIRange
}));
WeedOriginal.reinit();
(WeedOriginal.RulesDatabaseSet[0] as KnowlegeBaseTSARules).error = WeedOriginal.ErrorLearnSamples(WeedOriginal.RulesDatabaseSet[0]);
(WeedOriginal.RulesDatabaseSet[0] as KnowlegeBaseTSARules).RulesAcceptedFeatures = new List <bool>(WeedOriginal.AcceptedFeatures.ToList());
}
string added2 = (WeedOriginal.RulesDatabaseSet.Last() as KnowlegeBaseTSARules).RulesAcceptedFeatures.Aggregate(String.Empty, (current, v) => current + (" " + (v ? "1" : "0")));
File.AppendAllLines("./out2.txt", new List <string>()
{
WeedOriginal.RulesDatabaseSet.Last().RulesDatabase.Count + " " +
(WeedOriginal.RulesDatabaseSet.Last() as KnowlegeBaseTSARules).RulesAcceptedFeatures.Count(x => x) + " " + WeedOriginal.RMSEtoMSEforLearn(WeedOriginal.ErrorLearnSamples(WeedOriginal.RulesDatabaseSet.Last())) / 2 + " " + WeedOriginal.RMSEtoMSEforTest(WeedOriginal.ErrorTestSamples(WeedOriginal.RulesDatabaseSet.Last())) / 2 + " " + added2
});
Random rand = new Random();
for (int iter = 0; iter < maxiter; iter++)
{
List <KnowlegeBaseTSARules> newtstmp = new List <KnowlegeBaseTSARules>();
for (int k = 0; k < WeedOriginal.RulesDatabaseSet.Count; k++)
{
double fiBest = 1;
double fiWorst = (1 - (WeedOriginal.RulesDatabaseSet[k] as KnowlegeBaseTSARules).error);
if (!Double.IsNaN((WeedOriginal.RulesDatabaseSet[k] as KnowlegeBaseTSARules).error))
{
if (!Double.IsInfinity((WeedOriginal.RulesDatabaseSet[k] as KnowlegeBaseTSARules).error))
{
var CurrertChild =
Convert.ToInt32((MaxChild - MinChild) / (fiBest - fiWorst) * (1 - (WeedOriginal.RulesDatabaseSet[k] as KnowlegeBaseTSARules).error) +
(fiBest * MinChild - fiWorst * MaxChild) / (fiBest - fiWorst));
double delta = originalDelta * (maxiter - iter) / maxiter;
newtstmp.AddRange(WeedsCut.WeedsRegenerateIteration(WeedOriginal, (WeedOriginal.RulesDatabaseSet[k] as KnowlegeBaseTSARules), delta, rand, CurrertChild));
//
var item = newtstmp.Last();
item.RulesAcceptedFeatures = new List <bool>((WeedOriginal.RulesDatabaseSet[k] as KnowlegeBaseTSARules).RulesAcceptedFeatures);
for (int index = 0; index < item.RulesAcceptedFeatures.Count; index++)
{
if (Math.Sqrt(-2 * Math.Log(rand.NextDouble())) * Math.Cos(2 * Math.PI * rand.NextDouble()) > delta)
{
item.RulesAcceptedFeatures[index] = !item.RulesAcceptedFeatures[index];
}
}
while (item.RulesAcceptedFeatures.Count(x => x) > MaxUsingRule)
{
item.RulesAcceptedFeatures[(rand.Next(item.RulesAcceptedFeatures.Count))] = false;
}
while (item.RulesAcceptedFeatures.Count(x => x) < MinUsingRule)
{
item.RulesAcceptedFeatures[(rand.Next(item.RulesAcceptedFeatures.Count))] = true;
}
}
}
}
foreach (var weedBase in newtstmp)
{
RLS rls = new RLS();
var tmp = new TSAFuzzySystemWithErrorKnowledgeBase(WeedOriginal);
tmp.RulesDatabaseSet.Clear();
tmp.AcceptedFeatures = weedBase.RulesAcceptedFeatures.ToArray();
global::KLI.KLI s = new global::KLI.KLI();
tmp = s.Generate(tmp, new KLI_conf()
{
MaxValue = KLIRange
}) as TSAFuzzySystemWithErrorKnowledgeBase;
tmp.reinit();
(tmp.RulesDatabaseSet[0] as KnowlegeBaseTSARules).error = tmp.ErrorLearnSamples(tmp.RulesDatabaseSet[0]);
(tmp.RulesDatabaseSet[0] as KnowlegeBaseTSARules).RulesAcceptedFeatures = new List <bool>(tmp.AcceptedFeatures.ToList());
if (!double.IsNaN((tmp.RulesDatabaseSet[0] as KnowlegeBaseTSARules).error))
{
WeedOriginal.RulesDatabaseSet.Add(tmp.RulesDatabaseSet[0]);
string added = (tmp.RulesDatabaseSet[0] as KnowlegeBaseTSARules).RulesAcceptedFeatures.Aggregate(String.Empty, (current, v) => current + (" " + (v ? "1" : "0")));
File.AppendAllLines("./out2.txt", new List <string>()
{
tmp.RulesDatabaseSet[0].RulesDatabase.Count + " " +
(tmp.RulesDatabaseSet[0] as KnowlegeBaseTSARules).RulesAcceptedFeatures.Count(x => x) + " " + tmp.RMSEtoMSEforLearn(tmp.ErrorLearnSamples(tmp.RulesDatabaseSet[0])) / 2 + " " + tmp.RMSEtoMSEforTest(tmp.ErrorTestSamples(tmp.RulesDatabaseSet[0])) / 2 + " " + added
});
}
}
WeedOriginal.RulesDatabaseSet.RemoveAll(x => Double.IsInfinity((x as KnowlegeBaseTSARules).error) || Double.IsInfinity((x as KnowlegeBaseTSARules).error));
WeedOriginal.RulesDatabaseSet.Sort((c1, c2) => (c1 as KnowlegeBaseTSARules).error.CompareTo((c2 as KnowlegeBaseTSARules).error));
if (WeedOriginal.RulesDatabaseSet.Count > 6)
{
WeedOriginal.RulesDatabaseSet.RemoveRange(6, WeedOriginal.RulesDatabaseSet.Count - 6);
}
}
WeedOriginal.AcceptedFeatures = (WeedOriginal.RulesDatabaseSet[0] as KnowlegeBaseTSARules).RulesAcceptedFeatures.ToArray();
return(WeedOriginal);
}
void Init(ILearnAlgorithmConf Conf)
{
Config = Conf as IslandsConfig;
}
public override FuzzySystem.PittsburghClassifier.PCFuzzySystem TuneUpFuzzySystem(FuzzySystem.PittsburghClassifier.PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
PCFuzzySystem result = Classifier;
count_iteration = ((CuckooConf)conf).CuckooCountIterate;
count_particle = ((CuckooConf)conf).CuckooPopulationSize;
m = ((CuckooConf)conf).CuckooWorse;
p = ((CuckooConf)conf).CuckooLifeChance;
beta = ((CuckooConf)conf).CuckooBeta;
KnowlegeBasePCRules[] X = new KnowlegeBasePCRules[count_particle + 1];
double[] Errors = new double[count_particle + 1];
double[] Er = new double[count_particle + 1];
Random rnd = new Random();
int best = 0;
for (int i = 0; i < count_particle + 1; i++)
{
KnowlegeBasePCRules temp_c_Rule = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]);
X[i] = temp_c_Rule;
Errors[i] = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
}
///////////
for (int i = 0; i < count_iteration; i++)
{
X[0] = new KnowlegeBasePCRules(X[0]);
for (int k = 0; k < X[0].TermsSet.Count; k++)
{
for (int q = 0; q < X[0].TermsSet[k].CountParams; q++)
{
double b = (rnd.Next(1000, 2000) / Convert.ToDouble(1000));
X[0].TermsSet[k].Parametrs[q] = X[0].TermsSet[k].Parametrs[q] + Levi(BM(sigu(beta)), BM(1.0), beta);
}
}
for (int k = 0; k < X[0].Weigths.Length; k++)
{
X[0].Weigths[k] = rnd.NextDouble() / 200;
}
result.RulesDatabaseSet.Add(X[0]);
int temp_index = result.RulesDatabaseSet.Count - 1;
Errors[0] = result.ClassifyLearnSamples(result.RulesDatabaseSet[temp_index]);
result.RulesDatabaseSet.RemoveAt(temp_index);
int s = rnd.Next(1, count_particle + 1);
if (Errors[0] > Errors[s])
{
X[s] = X[0];
Errors[s] = Errors[0];
}
else
{
X[0] = X[s];
Errors[0] = Errors[s];
}
for (int v = 0; v < m; v++)
{
double max = Errors[1];
int ind = 1;
for (int r = 2; r < count_particle + 1; r++)
{
if (Errors[r] < max)
{
max = Errors[r];
ind = r;
}
else
{
};
}
double h = (rnd.Next(1, 1000) / Convert.ToDouble(1000));
if (h > p)
{
X[ind] = new KnowlegeBasePCRules(X[ind]);
for (int j = 0; j < X[ind].TermsSet.Count; j++)
{
for (int k = 0; k < X[ind].TermsSet[j].CountParams; k++)
{
X[ind].TermsSet[j].Parametrs[k] = X[0].TermsSet[j].Parametrs[k] + (rnd.Next(-1000, 1000) / Convert.ToDouble(1000));
}
for (int k = 0; k < X[ind].Weigths.Length; k++)
{
X[ind].Weigths[k] = X[0].Weigths[k] + (rnd.Next(1, 1000) / Convert.ToDouble(10000));
}
}
result.RulesDatabaseSet.Add(X[ind]);
temp_index = result.RulesDatabaseSet.Count - 1;
Errors[ind] = result.ClassifyLearnSamples(result.RulesDatabaseSet[temp_index]);
result.RulesDatabaseSet.RemoveAt(temp_index);
}
}
}
double min = Errors[0];
best = 0;
for (int g = 1; g < count_particle + 1; g++)
{
if (Errors[g] > min)
{
min = Errors[g];
best = g;
}
}
X[0] = X[best];
result.RulesDatabaseSet.Add(X[0]);
int t_index = result.RulesDatabaseSet.Count - 1;
Errors[0] = result.ClassifyLearnSamples(result.RulesDatabaseSet[t_index]);
result.RulesDatabaseSet.RemoveAt(t_index);
result.RulesDatabaseSet[0] = X[0];
result.RulesDatabaseSet[0].TermsSet.Trim();
return(result);
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approximate, ILearnAlgorithmConf conf)
{
SAFuzzySystem result = Approximate;
var config = (RLSconfig)conf;
numberOfIterations = config.NumberOfIterantions;
lambda = config.ForgettingFactor;
var knowledgeBaseToOptimize = new KnowlegeBaseSARules(result.RulesDatabaseSet[0]);
// r[0]
double[] consequents = new double[knowledgeBaseToOptimize.all_conq_of_rules.Length];
knowledgeBaseToOptimize.all_conq_of_rules.CopyTo(consequents, 0);
dividerXi = new double[result.LearnSamplesSet.CountSamples];
xiValue = new double[result.LearnSamplesSet.CountSamples][];
Vector r = new Vector(consequents);
// p[0]
double[][] p = new double[consequents.Length][];
for (int i = 0; i < consequents.Length; i++)
{
p[i] = new double[consequents.Length];
for (int j = 0; j < consequents.Length; j++)
{
p[i][j] = (i == j) ? 2000 : 0;
}
}
Matrix P = new Matrix(p);
// x, y
double[][] x = new double[result.LearnSamplesSet.CountSamples][];
double[] y = new double[result.LearnSamplesSet.CountSamples];
for (int i = 0; i < result.LearnSamplesSet.CountSamples; i++)
{
x[i] = result.LearnSamplesSet.DataRows[i].InputAttributeValue;
y[i] = result.LearnSamplesSet.DataRows[i].DoubleOutput;
xiValue[i] = new double[knowledgeBaseToOptimize.all_conq_of_rules.Length];
}
EvalXi(x, y, knowledgeBaseToOptimize);
// Main cycle
for (int i = 0; i < numberOfIterations; i++)
{
for (int j = 0; j < result.LearnSamplesSet.CountSamples; j++)
{
var temp1 = -1d * P;
var temp2 = new Matrix(Xi(j), false);
var temp3 = temp1 * temp2;
var temp4 = new Matrix(Xi(j), true);
var temp5 = temp4 * P * temp2;
var temp6 = lambda + temp5.Elements[0][0]; //// 1 >> lambda
var temp7 = temp3 / temp6;
var temp8 = temp4 * P;
var temp9 = temp7 * temp8;
P += temp9;
P /= lambda;
P = (P + -1 * P * temp2 / (lambda + (temp4 * P * temp2).Elements[0][0]) * temp4 * P) / lambda;
r += P * Xi(j) * (y[j] - Xi(j) * r);
}
}
knowledgeBaseToOptimize.all_conq_of_rules = r.Elements;
// Get the best knowledge base on the 1st place
result.RulesDatabaseSet.Add(knowledgeBaseToOptimize);
double errorBefore = result.approxLearnSamples(result.RulesDatabaseSet[0]),
errorAfter = result.approxLearnSamples(result.RulesDatabaseSet[result.RulesDatabaseSet.Count - 1]);
if (errorAfter < errorBefore)
{
result.RulesDatabaseSet.Remove(knowledgeBaseToOptimize);
result.RulesDatabaseSet.Insert(0, knowledgeBaseToOptimize);
}
return(result);
}
public override TSAFuzzySystem TuneUpFuzzySystem(TSAFuzzySystem Approximate, ILearnAlgorithmConf conf)
{
TSAFuzzySystem result = Approximate;
double errorBefore = result.approxLearnSamples(result.RulesDatabaseSet[0]);
var a = 2000;
#region Basic initialization
var config = (RLSconfig)conf;
numberOfIterations = config.NumberOfIterantions;
lambda = config.ForgettingFactor;
var knowledgeBaseToOptimize = new KnowlegeBaseTSARules(result.RulesDatabaseSet[0]);
var kbToOptimize = new KnowlegeBaseTSARules(result.RulesDatabaseSet[0]);
R = knowledgeBaseToOptimize.RulesDatabase.Count; // Number of rules
m = result.LearnSamplesSet.CountSamples; // Number of samples
n = knowledgeBaseToOptimize.RulesDatabase[0].RegressionConstantConsequent.Length; // Number of variables
#endregion
#region x, y
double[][] x = new double[m][];
double[] y = new double[m];
for (int i = 0; i < m; i++)
{
x[i] = result.LearnSamplesSet.DataRows[i].InputAttributeValue;
y[i] = result.LearnSamplesSet.DataRows[i].DoubleOutput;
}
#endregion
#region B
double[][] consequents = new double[n + 1][];
// B[0]
consequents[0] = new double[R];
for (int i = 0; i < R; i++)
{
consequents[0][i] = knowledgeBaseToOptimize.RulesDatabase[i].IndependentConstantConsequent;
}
// B[1..n+1]
for (int i = 1; i < n + 1; i++)
{
consequents[i] = new double[R];
for (int j = 0; j < R; j++)
{
consequents[i][j] = knowledgeBaseToOptimize.RulesDatabase[j].RegressionConstantConsequent[i - 1];
}
}
HyperVector B = new HyperVector(consequents);
#endregion
#region P
double[][] p = new double[n + 1][];
for (int i = 0; i < n + 1; i++)
{
p[i] = new double[n + 1];
for (int j = 0; j < n + 1; j++)
{
p[i][j] = (i == j) ? a : 0;
}
}
Matrix P = new Matrix(p);
#endregion
#region Xi
dividerXi = new double[m];
xiValue = new double[m][];
for (int i = 0; i < m; i++)
{
xiValue[i] = new double[R];
}
EvalXi(x, y, knowledgeBaseToOptimize);
// XiBold
xiBoldValue = new HyperVector[m];
EvalXiBold(x);
#endregion
GC.Collect();
//double[][] aDoubles = new[]
// {
// new[] { 0.1, 0.2, 0.123 },
// new[] { 1.213, 2.1, 1.2 },
// new[] { 13.3, 0.1231, 31.1 }
// },
// bDoubles = new[]
// {
// new[] { 0.1, 12.2, 5.445 },
// new[] { 5.3, 4.553, 1.545 },
// new[] { 3.4, 87.545, 0.255 }
// };
//Matrix aMatrix = new Matrix(aDoubles);
//HyperVector bVector = new HyperVector(bDoubles);
//HyperVector cVector = new HyperVector(aDoubles);
//var c = aMatrix * bVector;
//var cc = c;
//var d = bVector * cVector;
//var dd = d;
//var e = bVector ^ cVector;
//var ee = e;
//var f = cVector * aMatrix;
//var ff = f;
#region The Cycle
for (int i = 0; i < numberOfIterations; i++)
{
for (int j = 0; j < m; j++)
{
var temp1 = -1d * P;
var temp3 = temp1 * xiBoldValue[j];
var temp5 = xiBoldValue[j] * P * xiBoldValue[j];
var temp6 = lambda + temp5;
var temp7 = temp3 * (1d / temp6);
var temp8 = xiBoldValue[j] * P;
var temp9 = temp7 ^ temp8;
P += temp9;
P /= lambda;
////P = (P + (-1d * P * xiBoldValue[j] * (1d / (lambda + (xiBoldValue[j] * P * xiBoldValue[j]))) ^ xiBoldValue[j] * P)) / lambda;
B += P * xiBoldValue[j] * (y[j] - xiBoldValue[j] * B);
}
}
#endregion
#region Comparison
// Get consequents into the KB
for (int i = 0; i < R; i++)
{
knowledgeBaseToOptimize.RulesDatabase[i].IndependentConstantConsequent = B.Elements[0].Elements[i];
for (int j = 1; j < n + 1; j++)
{
knowledgeBaseToOptimize.RulesDatabase[i].RegressionConstantConsequent[j - 1] = B.Elements[j].Elements[i]; // NOT WORKING!!!
}
}
// Get the best knowledge base on the 1st place
double errorAfter = result.approxLearnSamples(kbToOptimize);
if (errorAfter < errorBefore)
{
result.RulesDatabaseSet.Insert(0, knowledgeBaseToOptimize);
}
else
{
result.RulesDatabaseSet.Insert(0, kbToOptimize);
// result.RulesDatabaseSet.Add(kbToOptimize);
}
return(result);
#endregion
}
public override FuzzySystem.PittsburghClassifier.PCFuzzySystem TuneUpFuzzySystem(FuzzySystem.PittsburghClassifier.PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
PCFuzzySystem result = Classifier;
FalsePositiveLearn = 0;
FalseNegativeLearn = 0;
FalsePositiveTest = 0;
FalseNegativeTest = 0;
string normalClass = "normal.";
for (int i = 0; i < Classifier.LearnSamplesSet.CountSamples; i++)
{
string ClassifierResult = Classifier.classifyBase(Classifier.LearnSamplesSet[i].InputAttributeValue, Classifier.RulesDatabaseSet[0]);
if (Classifier.LearnSamplesSet.DataRows[i].StringOutput.Contains(normalClass))
{
if (!ClassifierResult.Contains(normalClass))
{
FalsePositiveLearn++;
continue;
}
}
if (ClassifierResult.Contains(normalClass))
{
if (!Classifier.LearnSamplesSet.DataRows[i].StringOutput.Contains(normalClass))
{
FalseNegativeLearn++;
}
}
}
FalsePositiveLearn = FalsePositiveLearn / Classifier.LearnSamplesSet.CountSamples * 100;
FalseNegativeLearn = FalseNegativeLearn / Classifier.LearnSamplesSet.CountSamples * 100;
for (int i = 0; i < Classifier.TestSamplesSet.CountSamples; i++)
{
string ClassifierResult = Classifier.classifyBase(Classifier.TestSamplesSet[i].InputAttributeValue, Classifier.RulesDatabaseSet[0]);
if (Classifier.TestSamplesSet.DataRows[i].StringOutput.Contains(normalClass))
{
if (!ClassifierResult.Contains(normalClass))
{
FalsePositiveTest++;
continue;
}
}
if (ClassifierResult.Contains(normalClass))
{
if (!Classifier.TestSamplesSet.DataRows[i].StringOutput.Contains(normalClass))
{
FalseNegativeTest++;
}
}
}
FalsePositiveTest = FalsePositiveTest / Classifier.TestSamplesSet.CountSamples * 100;
FalseNegativeTest = FalseNegativeTest / Classifier.TestSamplesSet.CountSamples * 100;
Classifier.RulesDatabaseSet[0].TermsSet.Trim();
return(Classifier);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classify, ILearnAlgorithmConf conf)
{
result = Classify;
string folder_name = "";
foreach (var letter in result.LearnSamplesSet.FileName)
{
if (letter != '-')
{
folder_name += letter;
}
else
{
break;
}
}
numberOfFeatures = result.CountFeatures;
Init(conf);
rand = new Random();
HeadLeader = new bool[numberOfFeatures];
SetPopulation();
Population[0].CopyTo(HeadLeader, 0);
result.AcceptedFeatures = HeadLeader;
double HLAcc = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
iter = 0;
while (iter < MaxIter)
{
ChangePositions();
SortPopulation();
result.AcceptedFeatures = Population[0];
if (result.ClassifyLearnSamples(result.RulesDatabaseSet[0]) > HLAcc)
{
HLAcc = result.ClassifyLearnSamples(result.RulesDatabaseSet[0]);
Population[0].CopyTo(HeadLeader, 0);
}
iter++;
}
int count_ones = 0;
result.AcceptedFeatures = HeadLeader;
for (int j = 0; j < HeadLeader.Length; j++)
{
if (HeadLeader[j])
{
Console.Write("1 ");
count_ones++;
}
else
{
Console.Write("0 ");
}
}
Console.WriteLine();
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(result.RulesDatabaseSet[0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(result.RulesDatabaseSet[0]), 2));
File.AppendAllText("E:/TUSUR/GPO/Эксперименты/Behavior/RS" + folder_name + ".txt", "Признаки: " + count_ones + Environment.NewLine);
File.AppendAllText("E:/TUSUR/GPO/Эксперименты/Behavior/RS" + folder_name + ".txt", "Тест: " + Math.Round(result.ClassifyTestSamples(result.RulesDatabaseSet[0]), 2) + Environment.NewLine);
File.AppendAllText("E:/TUSUR/GPO/Эксперименты/Behavior/RS" + folder_name + ".txt", "Время: " + Environment.NewLine);
return(result);
}
public virtual void Init(ILearnAlgorithmConf Conf)
{
Config = Conf as RandomSearchConf;
MaxIter = ((RandomSearchConf)Conf).TRSCCountIteration;
numberOfAllParts = ((RandomSearchConf)Conf).TRSCCountparticles;
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
result = Classifier;
//Узнаем название папки с данными
string path_name = "../../OLD/Data/Keel/Classifier/KEEL-10/";
string folder_name = "";
foreach (var letter in result.LearnSamplesSet.FileName)
{
if (letter != '-')
{
folder_name += letter;
}
else
{
break;
}
}
groups = new List <int[]>();
Init(conf);
//Создаем новые обучающую и тестовую выбоки и удаляем из них некоторое количество случайных элементов
List <PCFuzzySystem> results = new List <PCFuzzySystem>();
for (int i = 0; i < numberOfPopulations; i++)
{
SampleSet new_learn = new SampleSet(path_name + folder_name + "/" + result.LearnSamplesSet.FileName);
SampleSet new_test = new SampleSet(path_name + folder_name + "/" + result.TestSamplesSet.FileName);
results.Add(new PCFuzzySystem(new_learn, new_test));
int ground = (int)Math.Round(results[i].LearnSamplesSet.DataRows.Count * 0.25);
for (int j = 0; j < ground; j++)
{
results[i].LearnSamplesSet.DataRows.RemoveAt(rand.Next(0, results[i].LearnSamplesSet.DataRows.Count));
}
}
Populations = new List <List <KnowlegeBasePCRules> >();
for (int i = 0; i < numberOfPopulations; i++)
{
Populations.Add(SetPopulation(new List <KnowlegeBasePCRules>()));
Populations[i] = ListPittsburgClassifierTool.SortRules(Populations[i], result);
}
NS = new int[m];
for (int i = 0; i < m; i++)
{
NS[i] = (N - 1) / m;
}
cur_iter = 0;
while (cur_iter < iter)
{
for (int p_i = 0; p_i < Populations.Count; p_i++)
{
groups = GroupStream(Populations[p_i]);
if (p_one > rand.NextDouble())
{
ChooseOneCluster(Populations[p_i]);
}
else
{
ChooseTwoClusters(Populations[p_i]);
}
Populations[p_i] = ListPittsburgClassifierTool.SortRules(Populations[p_i], results[p_i]);
//Console.WriteLine(cur_iter + " - Итерация");
//Console.WriteLine("Обуч. выборка = " + result.ErrorLearnSamples(Populations[p_i][0]));
//Console.WriteLine("Тест. выборка = " + result.ErrorTestSamples(Populations[p_i][0]));
}
cur_iter++;
}
//Выводим точность классификации для лучшей частицы из каждой популяции
for (int j = 0; j < Populations.Count; j++)
{
Populations[j] = ListPittsburgClassifierTool.SortRules(Populations[j], results[j]);
Console.WriteLine("Популяция №" + j + ":");
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(Populations[j][0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(Populations[j][0]), 2));
}
//Допобавляем в базу правил лучшие решения
if (result.RulesDatabaseSet.Count == 1)
{
result.RulesDatabaseSet.Clear();
}
for (int i = 0; i < Populations.Count; i++)
{
result.RulesDatabaseSet.Add(Populations[i][0]);
}
//Возвращаем результат
return(result);
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approx, ILearnAlgorithmConf conf)
{
Random rand = new Random(DateTime.Now.Millisecond);
SAFuzzySystem result = Approx;
BW.DoWork += new DoWorkEventHandler(BW_DoWork);
BW.RunWorkerCompleted += new RunWorkerCompletedEventHandler(BW_RunWorkerCompleted);
BW.RunWorkerAsync();
MultiGoalOptimaze_conf config = conf as MultiGoalOptimaze_conf;
string PathAlg = (new FileInfo(Application.ExecutablePath)).DirectoryName + "\\FS\\";
config.Init2(PathAlg, Approx.LearnSamplesSet.FileName);
countFuzzySystem = config.Итераций_алгоритма;
allowSqare = config.Допустимый_процент_перекрытия_по_площади_термов / 100;
allowBorder = config.Допустимый_процент_перекрытия_по_границам / 100;
int seedPath = rand.Next();
sizePercent = config.азмер_шага_по_точности;
sizeComplexity = config.азмер_шага_по_сложности;
sizeInteraply = config.азмер_шага_по_интерпретируемости;
diviver = config.Уменьшать_шаги_в;
trysBeforeDivide = config.Уменьшать_шаг_после;
path = config.path;
dataSetName = config.dataSetName;
toMany = config.азрешено_похожих_систем;
isPSO = config.toBool(config.Использовать_АРЧ);
// isBFO = config.toBool(config.Использовать_АПБ);
isANT = config.toBool(config.Использовать_НАМК);
isBEE = config.toBool(config.Использовать_САПК);
isES = config.toBool(config.Использовать_ЕС);
isGA = config.toBool(config.Использовать_ГА);
isTermShrink = config.toBool(config.Удалять_термы);
isRuleShrink = config.toBool(config.Удалять_правила);
isUnionTerm = config.toBool(config.Объединять_термы);
isLindBreakCross = config.toBool(config.Исключать_пересечение_лигвистически_далеких_термов);
countANT = config.Использовать_НАМК_раз_за_такт;
// countBFO = config.Использовать_за_такт_АПБ_раз;
countPSO = config.Использовать_за_такт_АРЧ_раз;
countBEE = config.Использовать_САПК_раз_за_такт;
countES = config.Использовать_ЕС_раз_за_такт;
countGA = config.Использовать_ГА_раз_за_такт;
typeComplexity = (int)config.Критерий_сложности;
typeInterpreting = (int)config.Критерий_интерпретируемости;
List <IAbstractLearnAlgorithm> learnAlgorithms = initAlgoritms();
List <ILearnAlgorithmConf> learnAlgorithmsconfig = initAlgoritmsConfigs(Approx.CountFeatures);
List <double> ValueLPercent = new List <double>();
List <double> ValueTPercent = new List <double>();
List <double> ValueComplexity = new List <double>();
List <double> ValueInterability = new List <double>();
List <double> SummaryGoods = new List <double>();
List <KnowlegeBaseSARules> Storage = new List <KnowlegeBaseSARules>();
List <int> candidate = new List <int>();
KnowlegeBaseSARules Best = result.RulesDatabaseSet[0];
baseLearn = result.approxLearnSamples(result.RulesDatabaseSet[0]);
ValueLPercent.Add(baseLearn);
ValueTPercent.Add(result.approxTestSamples(result.RulesDatabaseSet[0]));
baseComplexity = getComplexity(result);
ValueComplexity.Add(baseComplexity);
baseIntebility = getInterpreting(result, allowBorder, allowSqare);
ValueInterability.Add(baseIntebility);
Storage.Add(Best);
int NSCount = 0;
int deleted = 0;
for (int numberStep = 0; numberStep < countFuzzySystem; numberStep++)
{
bool mustToDivide = true;
int usedAlg = 0;
for (int tr = 0; tr < trysBeforeDivide; tr++)
{
deleted = 0;
// Parallel.For(0, learnAlgorithms.Count(), i =>
usedAlg = 0;
for (int i = 0; i < learnAlgorithms.Count(); i++)
{
Console.WriteLine("F****d in Storage.Add(new a_Rules(Best))");
Storage.Add(new KnowlegeBaseSARules(Best));
Console.WriteLine("F****d in result.RulesDatabaseSet.Clear()");
result.RulesDatabaseSet.Clear();
Console.WriteLine("F****d in result.RulesDatabaseSet.Add( Storage[Storage.Count - 1])");
result.RulesDatabaseSet.Add(Storage[Storage.Count - 1]);
usedAlg++;
bool before_VAlue = true;
try
{
learnAlgorithms[i].TuneUpFuzzySystem(result, learnAlgorithmsconfig[i]);
GC.Collect();
before_VAlue = false;
ValueLPercent.Add(result.approxLearnSamples(result.RulesDatabaseSet[0]));
ValueTPercent.Add(result.approxTestSamples(result.RulesDatabaseSet[0]));
ValueComplexity.Add(getComplexity(result));
ValueInterability.Add(getInterpreting(result, allowBorder, allowSqare));
double temp = ValueLPercent[ValueLPercent.Count - 1] + ValueComplexity[ValueComplexity.Count() - 1] + ValueInterability[ValueInterability.Count() - 1];
Storage[Storage.Count - 1] = result.RulesDatabaseSet[0];
if (double.IsNaN(temp))
{
Console.WriteLine("FuckAlarm " + i.ToString() + learnAlgorithms[i].ToString() + " is NAN");
ValueLPercent.RemoveAt(ValueLPercent.Count() - 1);
ValueTPercent.RemoveAt(ValueTPercent.Count() - 1);
ValueComplexity.RemoveAt(ValueComplexity.Count() - 1);
ValueInterability.RemoveAt(ValueInterability.Count() - 1);
Storage.RemoveAt(Storage.Count() - 1);
usedAlg--;
}
}
catch (Exception)
{
if (before_VAlue)
{
Console.WriteLine("FuckAlarm " + i.ToString() + learnAlgorithms[i].ToString() + " before VAlue");
}
else
{
Console.WriteLine("FuckAlarm " + i.ToString() + learnAlgorithms[i].ToString() + " after VAlue");
ValueLPercent.RemoveAt(ValueLPercent.Count() - 1);
ValueTPercent.RemoveAt(ValueTPercent.Count() - 1);
ValueComplexity.RemoveAt(ValueComplexity.Count() - 1);
ValueInterability.RemoveAt(ValueInterability.Count() - 1);
Storage.RemoveAt(Storage.Count() - 1);
}
}
NSCount++;
Console.WriteLine("F****d in ResultShow");
ResultShow += "[" + NSCount.ToString() + "]\t" + ValueLPercent[ValueLPercent.Count() - 1].ToString() + "\t" + ValueTPercent[ValueTPercent.Count() - 1].ToString() +
"\t" + ValueComplexity[ValueComplexity.Count() - 1].ToString() + "\t" + ValueInterability[ValueInterability.Count() - 1].ToString() + Environment.NewLine;
// i++;
}
//);
Console.WriteLine("F****d in deleted");
deleted = removeDublicate(ValueLPercent, ValueComplexity, ValueInterability, ValueTPercent, Storage, rand);
usedAlg -= deleted;
Console.WriteLine("F****d in candidate");
candidate = canBeNext(ValueLPercent, ValueComplexity, ValueInterability);
if (candidate.Count() > 0)
{
mustToDivide = false; break;
}
}
if (mustToDivide)
{
MessageBox.Show("Divided happend ");
sizePercent = sizePercent / diviver;
sizeComplexity = sizeComplexity / diviver;
sizeInteraply = sizeInteraply / diviver;
continue;
}
Console.WriteLine("F****d in SummaryGoods");
SummaryGoods = reCalcSummary(SummaryGoods, ValueLPercent, ValueComplexity, ValueInterability);
Console.WriteLine("F****d in indexofBest");
int indexofBest = getNewBest(candidate, SummaryGoods);
if (usedAsNext.ContainsKey(indexofBest))
{
usedAsNext[indexofBest]++;
}
else
{
usedAsNext.Add(indexofBest, 1);
}
Console.WriteLine("Best");
Best = Storage[indexofBest];
Console.WriteLine("F****d in for (int i = (Storage.Count - learnAlgorithms.Count); i < Storage.Count(); i++)");
int toSaveCounter = NSCount - usedAlg;
for (int i = (Storage.Count - usedAlg); i < Storage.Count(); i++)
{
result.RulesDatabaseSet[0] = Storage[i];
saveFS(result, path, dataSetName, seedPath, numberStep, toSaveCounter, Best.Equals(result.RulesDatabaseSet[0]));
toSaveCounter++;
}
Console.WriteLine("F****d in result.RulesDatabaseSet[0] = Best;");
result.RulesDatabaseSet[0] = Best;
Console.WriteLine("F****d in End");
baseLearn = result.approxLearnSamples(result.RulesDatabaseSet[0]);// ClassifyLearnSamples();
baseComplexity = getComplexity(result);
baseIntebility = getInterpreting(result, allowBorder, allowSqare);
candidate.Clear();
GC.Collect();
}
isEnd = true;
Thread.Sleep(10000);
result.RulesDatabaseSet[0].TermsSet.Trim();
return(result);
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approx, ILearnAlgorithmConf conf)
{
count_iteration = ((Param)conf).Количество_итераций;
count_populate = ((Param)conf).Число_осколков;
exploration = ((Param)conf).Фактор_исследования;
reduce_koef = ((Param)conf).Уменьшающий_коэффициент;
int iter = 0, i, j, count_terms, var = 0;
int count_cons;
double RMSE_best, cosFi, MSEbefore, MSEafter;
int Nd, variables, k = 1, best = 0;
SAFuzzySystem result = Approx;
int type = Approx.RulesDatabaseSet[0].TermsSet[0].CountParams;
Nd = Approx.RulesDatabaseSet[0].TermsSet.Count * type;
double[] X_best = new double[Nd + 1];
double[,] X_pred = new double[2, Nd + 1];
double[,] direction = new double[count_populate, Nd + 1];
double[,] d = new double[count_populate, Nd + 1];
double[,] explosion = new double[count_populate, Nd + 1];
double[,] shrapnel = new double[count_populate, Nd + 1];
cosFi = Math.Cos(2 * Math.PI / count_populate);
RMSE_best = Approx.approxLearnSamples(0);
count_cons = Approx.RulesDatabaseSet[0].all_conq_of_rules.Count();
double[] RMSE = new double[count_populate];
double[] RMSE_tst = new double[count_populate];
double[] RMSE2 = new double[count_populate];
double[] RMSE_pred = new double[2];
double[] cons_best = new double[count_cons];
count_terms = Approx.RulesDatabaseSet[0].TermsSet.Count;
variables = Approx.LearnSamplesSet.CountVars;
int[] terms = new int[variables];
KnowlegeBaseSARules[] X = new KnowlegeBaseSARules[count_populate];
for (int s = 0; s < count_populate - 1; s++)
{
X[s] = new KnowlegeBaseSARules(Approx.RulesDatabaseSet[0]);
Approx.RulesDatabaseSet.Add(X[s]);
}
RMSE_best = Approx.approxLearnSamples(0);
for (int h = 0; h < count_terms; h++)
{
if (Approx.RulesDatabaseSet[0].TermsSet[h].NumberOfInputVar == var)
{
terms[var]++;
}
else
{
terms[var + 1]++;
var++;
}
}
for (iter = 0; iter <= count_iteration; iter++)
{
best = 0;
if (iter == 0)
{
k = 1;
for (int h = 0; h < count_terms; h++)
{
for (int p = 0; p < type; p++)
{
shrapnel[0, k] = Approx.RulesDatabaseSet[0].TermsSet[h].Parametrs[p];
X_best[k] = shrapnel[0, k];
X_pred[0, k] = shrapnel[0, k];
X_pred[1, k] = shrapnel[0, k];
k++;
}
}
RMSE_pred[0] = Approx.approxLearnSamples(0);
RMSE_pred[1] = Approx.approxLearnSamples(0);
k = 1;
for (int h = 0; h < count_terms; h++)
{
for (int p = 0; p < type; p++)
{
d[0, k] = RandomNext(Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[h].NumberOfInputVar).Min, Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[h].NumberOfInputVar).Max);
k++;
}
}
}
for (i = 1; i <= Nd; i++)
{
if (exploration > iter)
{
for (j = 1; j < count_populate; j++)
{
int sum = 0, sum2 = 0;
generate:
sum++;
sum2++;
//формула расстояния исправлена
d[j, i] = d[j - 1, i] * randn();
//double sluch = randn();
//if (sluch < 0) d[j, i] = d[j - 1, i] * (-1) * Math.Pow(sluch, 2);
//else d[j, i] = d[j - 1, i] * Math.Pow(sluch, 2);
explosion[j, i] = d[j, i] * cosFi;
if (sum > 20)
{
if ((i + (type - 2)) % type == 0)
{
shrapnel[j, i] = (shrapnel[0, i] + explosion[j, i]) + (shrapnel[j, i - 1] - shrapnel[j, i]);
if (sum2 > 2)
{
shrapnel[j, i] = (shrapnel[0, i] + explosion[j, i]) + (shrapnel[j, i - type] - shrapnel[j, i]);
sum = 19;
}
if (sum2 > 3)
{
shrapnel[j, i] = (shrapnel[0, i] + explosion[j, i]) + (shrapnel[j, i - type] - shrapnel[j, i]) + (shrapnel[j, i - 1] - shrapnel[j, i]);
sum = 19;
sum2 = 0;
}
}
else
{
shrapnel[j, i] = (shrapnel[0, i] + explosion[j, i]) + (shrapnel[j, i - 1] - shrapnel[j, i]);
sum = 19;
}
}
else
{
shrapnel[j, i] = shrapnel[0, i] + explosion[j, i];
}
if ((i == 2) || (i == 1))
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Min;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 2) / type)].NumberOfInputVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Min; goto exit;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - type) / type)].NumberOfInputVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Min; goto exit;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != (variables - 1))
{
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i) / type)].NumberOfInputVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Max; goto exit;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i + 1) / type)].NumberOfInputVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Max; goto exit;
}
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar == (variables - 1))
{
if ((i == (count_terms * 3 - 1)) || (i == (count_terms * 3)))
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Max;
}
}
if (((i + (type - 2)) % type == 0) && (shrapnel[j, i] < shrapnel[j, i - 1]))
{
if (shrapnel[j, i] == Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Min)
{
i--;
}
goto generate;
}
if ((i % type == 0) && (shrapnel[j, i] < shrapnel[j, i - 1]))
{
goto generate;
}
if (i != 1)
{
if (((i - (type - 2)) % type == 0) && ((shrapnel[j, i] > shrapnel[j, i - 1]) || (shrapnel[j, i] > Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Max) || (shrapnel[j, i] < Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Min)))
{
goto generate;
}
}
if (((i + (type - 2)) % type == 0) && ((shrapnel[j, i] < Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Min) || (shrapnel[j, i] > Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Max)))
{
goto generate;
}
exit:
if (i > type)
{
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != 0)
{
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1 - type) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar - 1)
{
if (((i + (type - 2)) % type == 0) && ((shrapnel[j, i] < shrapnel[j, i - type])))
{
goto generate;
}
}
}
}
}
}
else
{
d[0, i] = d2(X_pred[0, i], X_pred[1, i], RMSE_pred[0], RMSE_pred[1]);
for (j = 1; j < count_populate; j++)
{
if ((X_pred[1, i] - X_pred[0, i]) != 0)
{
direction[j, i] = m(X_pred[0, i], X_pred[1, i], RMSE_pred[0], RMSE_pred[1]);
}
else
{
direction[j, i] = 1;
}
int sum = 0, sum2 = 0;
generate:
sum++;
sum2++;
double random;
random = randn();
if (random < 0)
{
explosion[j, i] = d[j - 1, i] * rand.NextDouble() * cosFi * (-1);
}
else
{
explosion[j, i] = d[j - 1, i] * rand.NextDouble() * cosFi;
}
if (sum2 > 50)
{
sum2 = 0;
}
if (sum > 20)
{
if ((i + (type - 2)) % type == 0)
{
shrapnel[j, i] = Shrapnel(explosion[j, i], shrapnel[0, i], d[j - 1, i], direction[j, i]) + (shrapnel[j, i - 1] - shrapnel[j, i]);
if (sum2 > 2)
{
shrapnel[j, i] = Shrapnel(explosion[j, i], shrapnel[0, i], d[j - 1, i], direction[j, i]) + (shrapnel[j, i - type] - shrapnel[j, i]);
sum = 19;
}
if (sum2 > 3)
{
shrapnel[j, i] = Shrapnel(explosion[j, i], shrapnel[0, i], d[j - 1, i], direction[j, i]) + (shrapnel[j, i - type] - shrapnel[j, i]) + (shrapnel[j, i - 1] - shrapnel[j, i]);
sum = 19;
sum2 = 0;
}
}
else
{
shrapnel[j, i] = Shrapnel(explosion[j, i], shrapnel[0, i], d[j - 1, i], direction[j, i]) + (shrapnel[j, i - 1] - shrapnel[j, i]);
sum = 19;
}
}
else
{
shrapnel[j, i] = Shrapnel(explosion[j, i], shrapnel[0, i], d[j - 1, i], direction[j, i]);
}
if ((i == 2) || (i == 1))
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Min;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 2) / type)].NumberOfInputVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Min; goto exit;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - type) / type)].NumberOfInputVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Min; goto exit;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != (variables - 1))
{
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i) / type)].NumberOfInputVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Max; goto exit;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i + 1) / type)].NumberOfInputVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Max; goto exit;
}
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar == (variables - 1))
{
if ((i == (count_terms * 3 - 1)) || (i == (count_terms * 3)))
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumberOfInputVar).Max;
}
}
if (((i + (type - 2)) % type == 0) && (shrapnel[j, i] < shrapnel[j, i - 1]))
{
if (shrapnel[j, i] == Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Min)
{
i--;
}
goto generate;
}
if ((i % type == 0) && (shrapnel[j, i] < shrapnel[j, i - 1]))
{
goto generate;
}
if (i != 1)
{
if (((i - (type - 2)) % type == 0) && ((shrapnel[j, i] > shrapnel[j, i - 1]) || (shrapnel[j, i] > Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Max) || (shrapnel[j, i] < Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Min)))
{
goto generate;
}
}
if (((i + (type - 2)) % type == 0) && ((shrapnel[j, i] < Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Min) || (shrapnel[j, i] > Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumberOfInputVar).Max)))
{
goto generate;
}
exit:
if (i > type)
{
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar != 0)
{
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1 - type) / type)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumberOfInputVar - 1)
{
if (((i + (type - 2)) % type == 0) && ((shrapnel[j, i] < shrapnel[j, i - type])))
{
goto generate;
}
}
}
}
d[j, i] = d[j - 1, i] / Math.Pow(Math.E, (double)iter / (double)reduce_koef);
}
}
}
for (int z = 0; z < count_populate; z++)
{
k = 1;
for (int h = 0; h < count_terms; h++)
{
for (int p = 0; p < type; p++)
{
Approx.RulesDatabaseSet[z].TermsSet[h].Parametrs[p] = shrapnel[z, k];
k++;
}
}
}
for (j = 0; j < count_populate; j++)
{
RMSE[j] = Approx.approxLearnSamples(j);
RMSE_tst[j] = Approx.approxTestSamples(j);
if (RMSE[j] < RMSE_best)
{
RMSE_best = RMSE[j];
best = j;
}
}
if ((iter != 0) && (iter % 1000 == 0))
{
Adaptive_LSM LSM = new Adaptive_LSM();
MSEbefore = RMSE[best];
KnowlegeBaseSARules zeroSolution = new KnowlegeBaseSARules(Approx.RulesDatabaseSet[0]);
Approx.RulesDatabaseSet[0] = new KnowlegeBaseSARules(Approx.RulesDatabaseSet[best]);
KnowlegeBaseSARules tempSolution = new KnowlegeBaseSARules(Approx.RulesDatabaseSet[best]);
Approx = LSM.TuneUpFuzzySystem(Approx, new NullConfForAll()) as SAFuzzySystem;
MSEafter = Approx.approxLearnSamples(0);
if (MSEafter > MSEbefore)
{
Approx.RulesDatabaseSet[0] = tempSolution;
RMSE2[best] = MSEbefore;
}
else
{
RMSE2[best] = MSEafter;
for (int p = 0; p < count_cons; p++)
{
cons_best[p] = Approx.RulesDatabaseSet[0].all_conq_of_rules[p];
}
}
if (RMSE2[best] < RMSE_best)
{
RMSE_best = RMSE2[best];
}
Approx.RulesDatabaseSet[best] = new KnowlegeBaseSARules(Approx.RulesDatabaseSet[0]);
Approx.RulesDatabaseSet[0] = new KnowlegeBaseSARules(zeroSolution);
for (int z = 0; z < count_populate; z++)
{
for (int p = 0; p < count_cons; p++)
{
Approx.RulesDatabaseSet[z].RulesDatabase[p].Cons_DoubleOutput = cons_best[p];
}
}
}
k = 1;
if (iter % 100 == 0)
{
k = 1;
}
for (int h = 0; h < count_terms; h++)
{
for (int p = 0; p < type; p++)
{
shrapnel[0, k] = shrapnel[best, k];
if (exploration > iter)
{
d[0, k] = RandomNext(Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[h].NumberOfInputVar).Min, Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[h].NumberOfInputVar).Max);
}
Approx.RulesDatabaseSet[0].TermsSet[h].Parametrs[p] = shrapnel[0, k];
k++;
}
}
if (iter % 10 == 0)
{
if (RMSE_pred[1] > RMSE2[best])
{
for (k = 1; k <= Nd; k++)
{
X_pred[0, k] = X_pred[1, k];
X_pred[1, k] = shrapnel[best, k];
}
RMSE_pred[0] = RMSE_pred[1];
RMSE_pred[1] = RMSE2[best];
}
}
else
{
if (RMSE_pred[1] > RMSE[best])
{
for (k = 1; k <= Nd; k++)
{
X_pred[0, k] = X_pred[1, k];
X_pred[1, k] = shrapnel[best, k];
}
RMSE_pred[0] = RMSE_pred[1];
RMSE_pred[1] = RMSE[best];
}
}
}
return(result);
}
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 override TSAFuzzySystem TuneUpFuzzySystem(TSAFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
Init(conf);
KnowlegeBaseTSARules temp_c_Rule = new KnowlegeBaseTSARules(Classifier.RulesDatabaseSet[0]);
TSAFuzzySystem result = Classifier;
string file_string = @"..\logs_" + result.TestSamplesSet.FileName + ".txt";
string file_string_to_txt = @"..\result_" + result.TestSamplesSet.FileName + ".txt";
for (int t = 0; t < population_count; t++)
{
monkey[t] = new KnowlegeBaseTSARules(result.RulesDatabaseSet[0]);
if (t > 3)
{
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);
}
}
}
double unlaidtest = result.ErrorLearnSamples(monkey[t]);
//result.UnlaidProtectionFix(monkey[t]);
//Console.WriteLine("Unlaid: " + result.ErrorLearnSamples(monkey[0]).ToString());
if (double.IsNaN(unlaidtest) || double.IsInfinity(unlaidtest))
{
result.UnlaidProtectionFix(monkey[t]);
}
// delete
testvals[t] = result.ErrorLearnSamples(monkey[t]);
Console.WriteLine("Begin: " + t.ToString() + " " + iter.ToString() + " " + testvals[t].ToString());
}
bestsolution = new KnowlegeBaseTSARules(monkey.SelectBest(result, 1)[0]);
bestsolutionnumber = result.ErrorLearnSamples(bestsolution);
deltaLength = result.RulesDatabaseSet[0].TermsSet.Sum(x => x.Parametrs.Length);
if (debug)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(file_string, true))
{
file.WriteLine(DateTime.Today.ToString() + "\t" + result.LearnSamplesSet.FileName);
file.WriteLine("Parameters:");
file.WriteLine("Population\t" + population_count.ToString());
file.WriteLine("Iteration count\t" + iter_amount.ToString());
file.WriteLine("Crawl count\t" + crawl_iter.ToString());
file.WriteLine("Jump count\t" + jump_iter.ToString());
file.WriteLine("Somersault count\t" + somersault_iter.ToString());
file.WriteLine("Crawl step\t" + step.ToString()); // crawl step
file.WriteLine("Jump step\t" + watch_jump_parameter.ToString());
file.WriteLine("Somersault left border\t" + somersault_interval_left.ToString());
file.WriteLine("Somersault right border\t" + somersault_interval_right.ToString());
file.WriteLine("\t\tMonkeys");
file.Write("Iterations\t");
for (int t = 0; t < population_count; t++)
{
file.Write("\t" + t);
}
file.WriteLine();
file.Write("0\tbegin");
for (int t = 0; t < population_count; t++)
{
file.Write("\t" + testvals[t].ToString());
}
// excel вставки
// наибольший в таблице
file.WriteLine();
}
}
//iter_amount = somersault_iter * (1 + jump_iter * (1 + crawl_iter));
iter_amount = (((crawl_iter + jump_iter) * jump_iter) + somersault_iter) * somersault_iter;
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++;
oneClimb(result, deltaLength, step);
CheckForBest(result);
//Console.WriteLine(iter_amount.ToString() + "/" + iter.ToString
// дебаг
if (debug)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(file_string, true))
{
file.Write(iter.ToString() + "\tcrawl");
for (int p = 0; p < population_count; p++)
{
file.Write("\t" + result.ErrorLearnSamples(monkey[p]).ToString());
}
file.WriteLine();
}
}
}
for (int e = 0; e < jump_iter; e++)
{
iter++;
oneWatchJump(result);
//Console.WriteLine(iter_amount.ToString() + "/" + iter.ToString());
CheckForBest(result);
// дебаг
if (debug)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(file_string, true))
{
file.Write(iter.ToString() + "\tlocaljump");
for (int p = 0; p < population_count; p++)
{
file.Write("\t" + result.ErrorLearnSamples(monkey[p]).ToString());
}
file.WriteLine();
}
}
}
}
for (int e = 0; e < somersault_iter; e++)
{
iter++;
oneGlobalJump(result);
CheckForBest(result);
// дебаг
if (debug)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(file_string, true))
{
file.Write(iter.ToString() + "\tglobaljump");
for (int p = 0; p < population_count; p++)
{
file.Write("\t" + result.ErrorLearnSamples(monkey[p]).ToString());
}
file.WriteLine();
}
}
Console.WriteLine(iter_amount.ToString() + "/" + iter.ToString());
}
}
//Console.WriteLine(final_iter.ToString() + "/" + final_counter.ToString());
//FOR VICTORY!!!
while ((final_iter < final_counter) && (last == true))
{
step *= 0.9;
watch_jump_parameter *= 0.9;
somersault_interval_left *= 0.9;
somersault_interval_right *= 0.9;
for (int r = 0; r < somersault_iter; r++)
{
oneClimb(result, deltaLength, step);
CheckForBest(result);
iter++;
}
for (int t = 0; t < jump_iter; t++)
{
oneWatchJump(result);
CheckForBest(result);
iter++;
}
for (int e = 0; e < crawl_iter; e++)
{
oneGlobalJump(result);
CheckForBest(result);
iter++;
}
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;
if (debug)
{
using (System.IO.StreamWriter file = new System.IO.StreamWriter(file_string, true))
{
file.WriteLine("Results\t" + result.ErrorLearnSamples(bestsolution).ToString() + "\t" + result.ErrorTestSamples(bestsolution).ToString());
}
}
if (totxt)
{
using (System.IO.StreamWriter file_result = new System.IO.StreamWriter(file_string_to_txt, true))
{
file_result.WriteLine(result.ErrorLearnSamples(bestsolution).ToString() + "\t" + result.ErrorTestSamples(bestsolution).ToString());
}
}
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classifier, ILearnAlgorithmConf conf)
{
iskl_prizn = "";
count_iteration = ((Param)conf).Количество_итераций;
count_populate = ((Param)conf).Число_осколков;
priznaki_usech = ((Param)conf).Усечённые_признаки;
iter_descrete = ((Param)conf).Итерации_дискр_алг;
int iter = 0, iter2, i, j, count_terms;//, count_iter ;
// int count_best2 = 0;//, best_pred ;
double RMSE_best, cosFi, RMSE_best2;
int Nd, variables, k = 1, best2 = 0;
PCFuzzySystem result = Classifier;
int type = Classifier.RulesDatabaseSet[0].TermsSet[0].CountParams;
Nd = Classifier.RulesDatabaseSet[0].TermsSet.Count * type;
double[] X_best = new double[Nd + 1];
double[,] X_pred = new double[2, Nd + 1];
double[,] direction = new double[count_populate, Nd + 1];
double[,] d = new double[count_populate, Nd + 1];
double[,] explosion = new double[count_populate, Nd + 1];
double[,] shrapnel = new double[count_populate, Nd + 1];
cosFi = Math.Cos(2 * Math.PI / count_populate);
RMSE_best = Classifier.ClassifyLearnSamples(Classifier.RulesDatabaseSet[0]);
RMSE_best2 = Classifier.ClassifyLearnSamples(Classifier.RulesDatabaseSet[0]);
double[] RMSE2 = new double[count_populate];
double[] RMSE_pred = new double[2];
variables = Classifier.LearnSamplesSet.CountVars;
count_terms = Classifier.RulesDatabaseSet[0].TermsSet.Count;
int[] terms = new int[variables];
double[] X_best2 = new double[variables];
double[,] d3 = new double[count_populate, variables];
double[,] priznak = new double[count_populate, variables];
for (i = 0; i < variables; i++)
{
Random random = new Random();
if (random.NextDouble() < 0.5)
{
priznak[0, i] = 1;
}
else
{
priznak[0, i] = 0;
}
}
KnowlegeBasePCRules[] X = new KnowlegeBasePCRules[count_populate];
for (int s = 0; s < count_populate - 1; s++)
{
X[s] = new KnowlegeBasePCRules(Classifier.RulesDatabaseSet[0]);
Classifier.RulesDatabaseSet.Add(X[s]);
}
for (iter2 = 0; iter2 < iter_descrete; iter2++)
{
best2 = 0;
if (iter == 0)
{
for (k = 0; k < variables; k++)
{
d3[0, k] = RandomNext(Classifier.LearnSamplesSet.InputAttributes[k].Min, Classifier.LearnSamplesSet.InputAttributes[k].Max);
}
}
for (i = 0; i < variables; i++)
{
for (j = 1; j < count_populate; j++)
{
generate:
d3[j, i] = d3[j - 1, i] * randn();
priznak[j, i] = d3[j, i] * cosFi;
if ((priznak[j, i] < Classifier.LearnSamplesSet.InputAttributes[i].Min) || (priznak[j, i] > Classifier.LearnSamplesSet.InputAttributes[i].Max))
{
goto generate;
}
Random random = new Random();
if (random.NextDouble() < descret(priznak[j, i]))
{
priznak[j, i] = 1;
}
else
{
priznak[j, i] = 0;
}
}
}
for (j = 1; j < count_populate; j++)
{
for (int h = 0; h < variables; h++)
{
if (priznak[j, h] == 1)
{
Classifier.AcceptedFeatures[h] = true;
}
else
{
Classifier.AcceptedFeatures[h] = false;
}
}
RMSE2[j] = Classifier.ClassifyLearnSamples(Classifier.RulesDatabaseSet[j]);
if (RMSE2[j] > RMSE_best2)
{
RMSE_best2 = RMSE2[j];
best2 = j;
}
}
for (k = 0; k < variables; k++)
{
priznak[0, k] = priznak[best2, k];
}
}
for (k = 0; k < variables; k++)
{
if (priznak[best2, k] == 1)
{
Classifier.AcceptedFeatures[k] = true;
}
else
{
Classifier.AcceptedFeatures[k] = false;
iskl_prizn += (k + 1).ToString() + " ";
}
}
return(result);
}
public PCFuzzySystem TuneUpFuzzySystem(PittsburgHybride Ocean, PCFuzzySystem Approximate, ILearnAlgorithmConf conf)
{
HybrideOcean = Ocean;
base.TuneUpFuzzySystem(Approximate, conf);
Ocean.Store(chooseDiscovers(1), this.ToString());
result.RulesDatabaseSet[0].TermsSet.Trim();
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 override TSAFuzzySystem TuneUpFuzzySystem(TSAFuzzySystem Approx, ILearnAlgorithmConf conf)
{
iskl_prizn = "";
count_iteration = ((Param)conf).Количество_итераций;
count_populate = ((Param)conf).Число_осколков;
exploration = ((Param)conf).Фактор_исследования;
reduce_koef = ((Param)conf).Уменьшающий_коэффициент;
priznaki_usech = ((Param)conf).Усечённые_признаки;
int iter = 0, i, j, count_terms;
double cosFi;
int Nd, variables, k = 1, best = 0;
string[] buf;
buf = priznaki_usech.Split(' ');
TSAFuzzySystem result = Approx;
int type = Approx.RulesDatabaseSet[0].TermsSet[0].CountParams;
Nd = Approx.RulesDatabaseSet[0].TermsSet.Count * type;
double[] X_best = new double[Nd + 1];
double[,] X_pred = new double[2, Nd + 1];
double[,] d = new double[count_populate, Nd + 1];
double[,] explosion = new double[count_populate, Nd + 1];
double[,] shrapnel = new double[count_populate, Nd + 1];
cosFi = Math.Cos(2 * Math.PI / count_populate);
double RMSE_best = Approx.approxLearnSamples(Approx.RulesDatabaseSet[0]);
double[] RMSE = new double[count_populate];
double[] RMSE2 = new double[count_populate];
double[] RMSE_pred = new double[2];
count_terms = Approx.RulesDatabaseSet[0].TermsSet.Count;
variables = Approx.LearnSamplesSet.CountVars;
double[] X_best2 = new double[variables];
double[,] priznak = new double[count_populate, variables];
for (i = 0; i < variables; i++)
{
priznak[0, i] = 1;
X_best2[i] = 1;
}
KnowlegeBaseTSARules[] X = new KnowlegeBaseTSARules[count_populate];
for (int s = 0; s < count_populate - 1; s++)
{
X[s] = new KnowlegeBaseTSARules(Approx.RulesDatabaseSet[0]);
Approx.RulesDatabaseSet.Add(X[s]);
}
if (buf[0] != "")
{
for (k = 0; k < buf.Count(); k++)
{
Approx.AcceptedFeatures[int.Parse(buf[k]) - 1] = false;
priznak[0, int.Parse(buf[k]) - 1] = 0;
//iskl_prizn += buf[k] + " ";
}
}
for (k = 0; k < variables; k++)
{
if (Approx.AcceptedFeatures[k] == false)
{
iskl_prizn += (k + 1).ToString() + " ";
}
}
RMSE_best2 = Approx.approxLearnSamples(Approx.RulesDatabaseSet[0]);
//for (j = 0; j < count_populate; j++)
//{
// for (int h = 0; h < variables; h++)
// {
// if (priznak[0, h] == 1) Approx.AcceptedFeatures[h] = true;
// else
// {
// Approx.AcceptedFeatures[h] = false;
// for (int h1 = 0; h1 < Approx.RulesDatabaseSet[0].RulesDatabase.Count(); h1++)
// {
// Approx.RulesDatabaseSet[j].RulesDatabase[h1].RegressionConstantConsequent[h] = 0;
// }
// }
// }
//}
countRules = Approx.RulesDatabaseSet[0].RulesDatabase.Count();
RMSE_best = Approx.approxLearnSamples(Approx.RulesDatabaseSet[0]);
for (iter = 0; iter <= count_iteration; iter++)
{
best = 0;
if (iter == 0)
{
k = 1;
for (int h = 0; h < count_terms; h++)
{
for (int p = 0; p < type; p++)
{
shrapnel[0, k] = Approx.RulesDatabaseSet[0].TermsSet[h].Parametrs[p];
X_best[k] = shrapnel[0, k];
X_pred[0, k] = shrapnel[0, k];
X_pred[1, k] = shrapnel[0, k];
k++;
}
}
RMSE_pred[0] = Approx.approxLearnSamples(Approx.RulesDatabaseSet[0]);
RMSE_pred[1] = Approx.approxLearnSamples(Approx.RulesDatabaseSet[0]);
k = 1;
for (int h = 0; h < count_terms; h++)
{
for (int p = 0; p < type; p++)
{
d[0, k] = RandomNext(Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[h].NumVar].Min, Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[h].NumVar].Max);
k++;
}
}
}
for (i = 1; i <= Nd; i++)
{
for (j = 1; j < count_populate; j++)
{
int sum = 0, sum2 = 0;
generate:
sum++;
sum2++;
d[j, i] = d[j - 1, i] * randn();
explosion[j, i] = d[j, i] * cosFi;
if (type == 2)
{
if (sum > 20)
{
if ((i + 1) % type == 0)
{
if (i != 1)
{
shrapnel[j, i] = (shrapnel[0, i] + explosion[j, i]) + (shrapnel[j, i] - shrapnel[j, i - 2]);
}
}
if (sum2 > 1000)
{
sum = 0; sum2 = 0;
}
}
else
{
shrapnel[j, i] = shrapnel[0, i] + explosion[j, i];
}
if (i != 1)
{
if (((i + 1) % 2 == 0) && (shrapnel[j, i] < shrapnel[j, i - 2]) && (Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumVar))
{
goto generate;
}
}
if (((i + 1) % 2 == 0) && (shrapnel[j, i] < Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i) / type].NumVar].Min))
{
goto generate;
}
if (((i + 1) % 2 == 0) && (shrapnel[j, i] > Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i) / type].NumVar].Max))
{
goto generate;
}
if ((i % 2 == 0) && (shrapnel[j, i] < 0))
{
goto generate;
}
}
if (type != 2)
{
if (sum > 20)
{
if ((i + (type - 2)) % type == 0)
{
shrapnel[j, i] = (shrapnel[0, i] + explosion[j, i]) + (shrapnel[j, i - 1] - shrapnel[j, i]);
if (sum2 > 2)
{
shrapnel[j, i] = (shrapnel[0, i] + explosion[j, i]) + (shrapnel[j, i - type] - shrapnel[j, i]);
sum = 19;
}
if (sum2 > 3)
{
shrapnel[j, i] = (shrapnel[0, i] + explosion[j, i]) + (shrapnel[j, i - type] - shrapnel[j, i]) + (shrapnel[j, i - 1] - shrapnel[j, i]);
sum = 19;
sum2 = 0;
}
}
else
{
shrapnel[j, i] = (shrapnel[0, i] + explosion[j, i]) + (shrapnel[j, i - 1] - shrapnel[j, i]);
sum = 19;
}
}
else
{
shrapnel[j, i] = shrapnel[0, i] + explosion[j, i];
}
}
if (type != 2)
{
if ((i == 2) || (i == 1))
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumVar].Min;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 2) / type)].NumVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumVar].Min; goto exit;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - type) / type)].NumVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumVar].Min; goto exit;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumVar != (variables - 1))
{
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i) / type)].NumVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumVar].Max; goto exit;
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i + 1) / type)].NumVar)
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumVar].Max; goto exit;
}
}
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumVar == (variables - 1))
{
if ((i == (count_terms * 3 - 1)) || (i == (count_terms * 3)))
{
shrapnel[j, i] = Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i - 1) / type].NumVar].Max;
}
}
if (((i + (type - 2)) % type == 0) && (shrapnel[j, i] < shrapnel[j, i - 1]))
{
if (shrapnel[j, i] == Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumVar].Min)
{
i--;
}
goto generate;
}
if ((i % type == 0) && (shrapnel[j, i] < shrapnel[j, i - 1]))
{
goto generate;
}
if (i != 1)
{
if (((i - (type - 2)) % type == 0) && ((shrapnel[j, i] > shrapnel[j, i - 1]) || (shrapnel[j, i] > Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumVar].Max) || (shrapnel[j, i] < Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumVar].Min)))
{
goto generate;
}
}
if (((i + (type - 2)) % type == 0) && ((shrapnel[j, i] < Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumVar].Min) || (shrapnel[j, i] > Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[(int)(i / type)].NumVar].Max)))
{
goto generate;
}
exit:
if (i > type)
{
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumVar != 0)
{
if (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1 - type) / type)].NumVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / type)].NumVar - 1)
{
if (((i + (type - 2)) % type == 0) && ((shrapnel[j, i] < shrapnel[j, i - type])))
{
goto generate;
}
}
}
}
}
// else
// {
// if (i > 1)
// {
// if ((i%2!=0) && (shrapnel[j, i] < shrapnel[j, i - 2]) && (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / 2)].NumberOfInputVar == Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 2) / 2)].NumberOfInputVar))
// {
// goto generate;
// }
// if((i%2!=0) && (shrapnel[j, i] > Approx.LearnSamplesSet.InputAttribute(Approx.RulesDatabaseSet[0].TermsSet[(int)(i / 2)].NumberOfInputVar).Max) && (Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 1) / 2)].NumberOfInputVar != Approx.RulesDatabaseSet[0].TermsSet[(int)((i - 2) / 2)].NumberOfInputVar))
// {
// goto generate;
// }
// }
//}
}
}
for (int z = 0; z < count_populate; z++)
{
k = 1;
for (int h = 0; h < count_terms; h++)
{
for (int p = 0; p < type; p++)
{
Approx.RulesDatabaseSet[z].TermsSet[h].Parametrs[p] = shrapnel[z, k];
k++;
}
}
}
for (j = 0; j < count_populate; j++)
{
RMSE[j] = Approx.approxLearnSamples(Approx.RulesDatabaseSet[j]);
if (RMSE[j] < RMSE_best)
{
RMSE_best = RMSE[j];
best = j;
}
}
k = 1;
for (int h = 0; h < count_terms; h++)
{
for (int p = 0; p < type; p++)
{
shrapnel[0, k] = shrapnel[best, k];
if (exploration > iter)
{
d[0, k] = RandomNext(Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[h].NumVar].Min, Approx.LearnSamplesSet.InputAttributes[Approx.RulesDatabaseSet[0].TermsSet[h].NumVar].Max);
}
Approx.RulesDatabaseSet[0].TermsSet[h].Parametrs[p] = shrapnel[0, k];
k++;
}
}
if (iter % 10 == 0)
{
if (RMSE_pred[1] > RMSE2[best])
{
for (k = 1; k <= Nd; k++)
{
X_pred[0, k] = X_pred[1, k];
X_pred[1, k] = shrapnel[best, k];
}
RMSE_pred[0] = RMSE_pred[1];
RMSE_pred[1] = RMSE2[best];
}
}
else
{
if (RMSE_pred[1] > RMSE[best])
{
for (k = 1; k <= Nd; k++)
{
X_pred[0, k] = X_pred[1, k];
X_pred[1, k] = shrapnel[best, k];
}
RMSE_pred[0] = RMSE_pred[1];
RMSE_pred[1] = RMSE[best];
}
}
}
return(result);
}
public override SAFuzzySystem TuneUpFuzzySystem(SAFuzzySystem Approximate, ILearnAlgorithmConf conf) // + override
{
result = Approximate;
List <KnowlegeBaseSARules> Archive = new List <KnowlegeBaseSARules>();
List <double> ErrorsArchive = new List <double>();
var config = (DynamicTuneConf)conf;
maxError = config.MaxError;
RuleCount = config.RulesCount;
TryCount = config.TryCount;
double error = result.RMSEtoMSEdiv2forLearn(result.approxLearnSamples(result.RulesDatabaseSet[0]));
var kbToOptimize = new KnowlegeBaseSARules(result.RulesDatabaseSet[0]);
var kbBest = new KnowlegeBaseSARules(kbToOptimize);
double errorBefore = Double.MaxValue;
result.UnlaidProtectionFix(kbToOptimize);
List <input_space> variable_spaces = new List <input_space>();
for (int i = 0; i < result.LearnSamplesSet.InputAttributes.Count; i++)
{
List <Term> terms_of_variable = new List <Term>();
terms_of_variable = kbToOptimize.TermsSet.Where(term => term.NumVar == i).ToList();
variable_spaces.Add(new input_space(terms_of_variable, i));
}
int indexRegion = -1,
indexVar = -1,
number_of_input_variables = variable_spaces.Count;
int tryCount = 0;
while (error > maxError)
{
if (Double.IsInfinity(error))
{
throw new Exception("Something went wrong, error is Infinity, region: " + indexRegion);
}
if (Double.IsNaN(error))
{
throw new Exception("Something went wrong, error is NaN, region: " + indexRegion);
}
region_side[][] sides = new region_side[number_of_input_variables][];
for (int i = 0; i < number_of_input_variables; i++)
{
sides[i] = variable_spaces[i].get_region_sides();
}
var cartresult = CartesianProduct.Get(sides);
List <region2> regions = new List <region2>();
foreach (var x in cartresult)
{
regions.Add(new region2(x.ToList(), result, variable_spaces));
}
List <double> region_errors = regions.Select(x => x.region_error()).ToList();
indexRegion = region_errors.IndexOf(region_errors.Max());
for (int i = 0; i < region_errors.Count; i++)
{
if (Double.IsNaN(region_errors[i]) || Double.IsInfinity(region_errors[i]) ||
Double.IsNegativeInfinity(region_errors[i]) || Double.IsPositiveInfinity(region_errors[i]))
{
region_errors[i] = 0;
}
}
List <double> variable_errors = regions[indexRegion].variable_errors();
bool check1 = false;
for (int i = 1; i < variable_errors.Count; i++)
{
if (variable_errors[i - 1] != variable_errors[i])
{
check1 = true;
break;
}
}
if (!check1)
{
indexVar = StaticRandom.Next(variable_errors.Count - 1);
}
else
{
indexVar = variable_errors.IndexOf(variable_errors.Max());
}
Term new_term = regions[indexRegion].new_term(indexVar);
result.RulesDatabaseSet[0] = kbToOptimize;
kbToOptimize.TermsSet.Add(new_term);
// Rules (CHECK REFERENCE TYPES)
int @var = indexVar;
var rulesLeft = kbToOptimize.RulesDatabase.Where(
rule => rule.ListTermsInRule.Contains(regions[indexRegion].sides[indexVar].left)).ToList();
var rulesRight = kbToOptimize.RulesDatabase.Where(
rule => rule.ListTermsInRule.Contains(regions[indexRegion].sides[indexVar].right)).ToList();
for (int j = 0; j < rulesLeft.Count; j++)
{
int[] order = new int[rulesLeft[j].ListTermsInRule.Count];
for (int k = 0; k < rulesLeft[j].ListTermsInRule.Count; k++)
{
Term temp_term = rulesLeft[j].ListTermsInRule[k];
if (temp_term == regions[indexRegion].sides[indexVar].left)
{
temp_term = new_term;
}
order[k] = kbToOptimize.TermsSet.FindIndex(x => x == temp_term);
}
///!!!!
double temp_approx_Values = kbToOptimize.RulesDatabase[j].IndependentConstantConsequent;
/* double[] temp_approx_RegressionConstantConsequent =
* kbToOptimize.RulesDatabase[j].RegressionConstantConsequent.Clone() as double[];
*/
SARule temp_rule = new SARule(
kbToOptimize.TermsSet, order, temp_approx_Values);
// double[] dC = null;
//!!!
temp_rule.IndependentConstantConsequent = KNNConsequent.NearestApprox(result, temp_rule.ListTermsInRule.ToList());
kbToOptimize.RulesDatabase.Add(temp_rule);
//!!!
rulesLeft[j].IndependentConstantConsequent = KNNConsequent.NearestApprox(result, rulesLeft[j].ListTermsInRule.ToList());
// rulesLeft[j].RegressionConstantConsequent = (double[])dC.Clone();
}
foreach (var rule in rulesRight)
{
//!!!
rule.IndependentConstantConsequent = KNNConsequent.NearestApprox(
result, rule.ListTermsInRule.ToList());
// rule.RegressionConstantConsequent = dC;
}
variable_spaces[indexVar].terms.Add(new_term);
variable_spaces[indexVar].terms.Sort(new CompararerByPick());
// Re-evaluate the system's error
error = result.RMSEtoMSEdiv2forLearn(result.ErrorLearnSamples(kbToOptimize));
if ((kbToOptimize.RulesDatabase.Count > config.RulesCount))
{
break;
}
#if Console
Console.WriteLine(error + " " + kbToOptimize.TermsSet.Count + " terms\n");
for (int i = 0; i < variable_spaces.Count; i++)
{
Console.WriteLine(variable_spaces[i].terms.Count + " термов по " + i + "му параметру\n");
}
#endif
result.RulesDatabaseSet[0] = kbToOptimize;
// Get the best knowledge base on the 1st place
if (error < errorBefore)
{
kbBest = new KnowlegeBaseSARules(kbToOptimize);
errorBefore = error;
tryCount = 0;
}
else
{
tryCount++;
}
if (tryCount > TryCount)
{
break;
}
}
result.RulesDatabaseSet[0] = kbBest;
RuleCount = kbBest.RulesDatabase.Count;
TryCount = tryCount;
return(result);
}
public override SAFuzzySystem TuneUpFuzzySystem(FuzzySystem.SingletoneApproximate.SAFuzzySystem Approximate, ILearnAlgorithmConf config)
{
theFuzzySystem = Approximate;
if (theFuzzySystem.RulesDatabaseSet.Count == 0)
{
throw new System.FormatException("Что то не то с входными данными");
}
OptimizeTermShrinkHardCoreConf Config = config as OptimizeTermShrinkHardCoreConf;
count_shrink = Config.OTSHCCountShrinkTerm;
for (int i = 0; i < Approximate.CountFeatures; i++)
{
int count_terms_for_var = Approximate.RulesDatabaseSet[0].TermsSet.FindAll(x => x.NumVar == i).Count;
if (count_terms_for_var >= count_shrink)
{
int shrinkcounter = count_shrink;
List <int> Varians_of_cut = new List <int>();
for (int j = 0; j < count_terms_for_var; j++)
{
if (shrinkcounter > 0)
{
Varians_of_cut.Add(0);
}
else
{
Varians_of_cut.Add(1);
}
shrinkcounter--;
}
Generate_all_variant_in_pool(Varians_of_cut);
for (int j = 0; j < Pull_of_systems.Count; j++)
{
KnowlegeBaseSARules current = MakeCut(Approximate.RulesDatabaseSet[0], Pull_of_systems[j], i);
Systems_ready_to_test.Add(current);
errors_of_systems.Add(theFuzzySystem.approxLearnSamples(current));
}
Pull_of_systems.Clear();
}
}
int best_index = errors_of_systems.IndexOf(errors_of_systems.Min());
theFuzzySystem.RulesDatabaseSet[0] = Systems_ready_to_test[best_index];
return(theFuzzySystem);
}
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 override TSAFuzzySystem TuneUpFuzzySystem(TSAFuzzySystem FSystem, ILearnAlgorithmConf conf)
{
return(UniversalMethod(FSystem, conf) as TSAFuzzySystem);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classify, ILearnAlgorithmConf conf)
{
result = Classify;
string folder_name = "";
foreach (var letter in result.LearnSamplesSet.FileName)
{
if (letter != '-')
{
folder_name += letter;
}
else
{
break;
}
}
numberOfFeatures = result.CountFeatures;
Init(conf);
HeadLeader = new bool[numberOfFeatures];
VelocityVector = new bool[numberOfFeatures];
VelocityVectorLL = new bool[numberOfFeatures];
VelocityVectorHL = new bool[numberOfFeatures];
SetPopulation();
LocalLeaders = new List <bool[]>();
ExplorerParticles = new List <bool[]>();
AimlessParticles = new List <bool[]>();
iter = 0;
while (iter < MaxIter)
{
SortPopulation();
SetRoles();
ChangeExplorersPositions();
ChangeAimlessPositions();
DiscardRoles();
iter++;
}
SortPopulation();
result.AcceptedFeatures = Population[0];
for (int j = 0; j < Population[0].Length; j++)
{
if (Population[0][j])
{
Console.Write("1 ");
}
else
{
Console.Write("0 ");
}
}
Console.WriteLine();
Console.WriteLine("Обуч: " + Math.Round(result.ClassifyLearnSamples(result.RulesDatabaseSet[0]), 2));
Console.WriteLine("Тест: " + Math.Round(result.ClassifyTestSamples(result.RulesDatabaseSet[0]), 2));
return(result);
}
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Class, ILearnAlgorithmConf conf) // Здесь ведется оптимизация вашим алгоритмом
{
theFuzzySystem = Class;
// Console.WriteLine(theFuzzySystem.RulesDatabaseSet[0].TermsSet.Count);
iterMax = ((gsa_conf)conf).Количество_итераций;
MCount = ((gsa_conf)conf).Количество_частиц;
G0 = ((gsa_conf)conf).Гравитационная_постоянная;
alpha = ((gsa_conf)conf).Коэффициент_уменьшения;
epsilon = ((gsa_conf)conf).Малая_константа;
X = new KnowlegeBasePCRules[MCount];
Errors = new double[MCount];
mass = new double[MCount];
temp_c_Rule = new KnowlegeBasePCRules(theFuzzySystem.RulesDatabaseSet[0]);
X[0] = temp_c_Rule;
Errors[0] = theFuzzySystem.ErrorLearnSamples(X[0]);
ErrorZero = Errors[0];
ErrorBest = Errors[0];
BestSolution = new KnowlegeBasePCRules(theFuzzySystem.RulesDatabaseSet[0]);
R = new double[MCount][, , ];
speed = new double[MCount, X[0].TermsSet.Count, X[0].TermsSet[0].Parametrs.Count()];
for (int i = 0; i < MCount; i++)
{
R[i] = new double[MCount, X[0].TermsSet.Count, X[0].TermsSet[0].Parametrs.Count()];
}
RR = new double[MCount, MCount];
a = new double[MCount, X[0].TermsSet.Count, X[0].TermsSet[0].Parametrs.Count()];
for (int i = 1; i < MCount; i++)
{
temp_c_Rule = new KnowlegeBasePCRules(theFuzzySystem.RulesDatabaseSet[0]);
X[i] = temp_c_Rule;
for (int j = 0; j < X[i].TermsSet.Count; j++)
{
for (int k = 0; k < X[i].TermsSet[j].Parametrs.Count(); k++)
{
X[i].TermsSet[j].Parametrs[k] = GaussRandom.Random_gaussian(rand, X[i].TermsSet[j].Parametrs[k], 0.1 * (X[i].TermsSet[j].Parametrs[k])) + theFuzzySystem.LearnSamplesSet.InputAttributes[X[i].TermsSet[j].NumVar].Scatter * 0.05;
}
}
//theFuzzySystem.RulesDatabaseSet.Add(X[i]);
//theFuzzySystem.UnlaidProtectionFix(theFuzzySystem.RulesDatabaseSet.Count - 1);
//Errors[i] = theFuzzySystem.ErrorLearnSamples(X[i]);
//X[i] = theFuzzySystem.RulesDatabaseSet[theFuzzySystem.RulesDatabaseSet.Count - 1];
//theFuzzySystem.RulesDatabaseSet.Remove(X[i]);
theFuzzySystem.UnlaidProtectionFix(X[i]);
Errors[i] = theFuzzySystem.ErrorLearnSamples(X[i]);
}
for (int iter = 0; iter < iterMax; iter++)
{
//g(t) = G(0)*e^(-a*t/T);
G = G0 * Math.Pow(Math.E, ((-1) * alpha * iter / iterMax));
algorithm();
for (int r = 0; r < MCount; r++)
{
theFuzzySystem.UnlaidProtectionFix(X[r]);
Errors[r] = theFuzzySystem.ErrorLearnSamples(X[r]);
}
minValue = Errors.Min();
iminIndex = Errors.ToList().IndexOf(minValue);
if (minValue < ErrorBest)
{
ErrorBest = minValue;
BestSolution = new KnowlegeBasePCRules(X[iminIndex]);
}
}
//theFuzzySystem.RulesDatabaseSet[0] = BestSolution;
if (ErrorBest < ErrorZero)
{
theFuzzySystem.RulesDatabaseSet[0] = BestSolution;
}
return(theFuzzySystem);
}
//основные вычисления
public override PCFuzzySystem TuneUpFuzzySystem(PCFuzzySystem Classify, ILearnAlgorithmConf conf)
{
rand = new Random();
result = Classify;
Init(conf);
SetPopulation();
KnowlegeBasePCRules BEST = new KnowlegeBasePCRules(result.RulesDatabaseSet[0]);
double bestError = result.ErrorLearnSamples(BEST);
//отчистка консоли
#if debug
Console.Clear();
#endif
//запуск итераций
for (int it = 0; it < iter; it++)
{
#if debug
//вывод номера итерации
Console.Write("Итерация __№__ = ");
Console.WriteLine(it);
#endif
//расчитыавем значение фитнес-функции
Population = ListPittsburgClassifierTool.SortRules(Population, result);
double[] K = new double[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
K[i] = result.ErrorLearnSamples(Population[i]);
#if debug
Console.Write("Значние K[i1] = ");
Console.WriteLine(K[i]);
#endif
if (double.IsNaN(K[i]) || double.IsInfinity(K[i]))
{
result.UnlaidProtectionFix(Population[i]);
K[i] = result.ErrorLearnSamples(Population[i]);
#if debug
Console.Write("Значние K[i2] = ");
Console.WriteLine(K[i]);
#endif
}
}
Kworst = K.Max();
if (double.IsNaN(Kworst) || double.IsInfinity(Kworst))
{
int iworst = K.ToList().IndexOf(Kworst);
#if debug
Console.Write("Значние iworst = ");
Console.WriteLine(iworst);
#endif
}
#if debug
//вывод Kworst
Console.Write("Значние KWorst = ");
Console.WriteLine(Kworst);
#endif
Kbest = K.Min();
#if debug
//вывод Kbest
Console.Write("Значние Kbest = ");
Console.WriteLine(Kbest);
#endif
int ibest = K.ToList().IndexOf(Kbest);
#if debug
//вывод ibest
Console.Write("Значние ibest = ");
Console.WriteLine(ibest);
#endif
//перебрать значения фитнес функции
//расчитыавем значение D
double dit;
dit = it;
double diter;
diter = iter;
double D = (dmax * (rand.NextDouble() * 2 - 1) * (dit / diter));
//расчитываем значение rand1 для D
double rand1;
rand1 = D / (dmax * (it) / iter);
#if debug
//выводим значение rand1 для D
Console.Write("Значение Drand = ");
Console.WriteLine(rand1);
//выводим значение D
Console.Write("Значение __D__ = ");
Console.WriteLine(D);
#endif
//расчитыавем значение Xfood
double divide = K.Select(x => 1 / x).ToList().Sum();
var Xfood = new KnowlegeBasePCRules(Population[0]);
for (int t = 0; t < Xfood.TermsSet.Count; t++)
{
for (int p = 0; p < Xfood.TermsSet[t].CountParams; p++)
{
Xfood.TermsSet[t].Parametrs[p] = 0;
for (int i = 0; i < Population.Length; i++)
{
Xfood.TermsSet[t].Parametrs[p] += Population[i].TermsSet[t].Parametrs[p] / K[i];
#if debug
//выводим значение Xfood
Console.Write("Значение Xfood = ");
Console.WriteLine(Xfood.TermsSet[t].Parametrs[p]);
#endif
}
Xfood.TermsSet[t].Parametrs[p] /= divide;
}
}
#if debug
//вывод divide
Console.Write("Значние divide = ");
Console.WriteLine(divide);
#endif
//расчитываем значение Kfood
double Kfood = result.ErrorLearnSamples(Xfood);
if (double.IsNaN(Kfood) || double.IsInfinity(Kfood))
{
result.UnlaidProtectionFix(Xfood);
Kfood = result.ErrorLearnSamples(Xfood);
}
#if debug
//выводим значение Kfood
Console.Write("Значение Kfood = ");
Console.WriteLine(Kfood);
#endif
//расчитываем значение Cfood
double Cfood = 2 * (1 - (dit / diter));
#if debug
//выводим значение Cfood
Console.Write("Значение Cfood = ");
Console.WriteLine(Cfood);
#endif
//расчитываем значение Bfood
KnowlegeBasePCRules[] Bfood = new KnowlegeBasePCRules[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
Bfood[i] = new KnowlegeBasePCRules(Population[i]);
double KRoofifood = CalcKroof(K[i], Kfood);
KnowlegeBasePCRules Xroofifood = new KnowlegeBasePCRules(CalcXroof(Population[i], Xfood));
for (int t = 0; t < Bfood[i].TermsSet.Count; t++)
{
for (int p = 0; p < Bfood[i].TermsSet[t].CountParams; p++)
{
Bfood[i].TermsSet[t].Parametrs[p] = Cfood * KRoofifood * Xroofifood.TermsSet[t].Parametrs[p];
#if debug
//выводим значение Bfood
Console.Write("Значение Bfood = ");
Console.WriteLine(Bfood[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
//расчитываем значение Bbest
KnowlegeBasePCRules[] Bbest = new KnowlegeBasePCRules[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
Bbest[i] = new KnowlegeBasePCRules(Population[i]);
double KRoofifood = CalcKroof(K[i], K[ibest]);
KnowlegeBasePCRules Xroofifood = new KnowlegeBasePCRules(CalcXroof(Population[i], Population[ibest]));
for (int t = 0; t < Bbest[i].TermsSet.Count; t++)
{
for (int p = 0; p < Bbest[i].TermsSet[t].CountParams; p++)
{
Bbest[i].TermsSet[t].Parametrs[p] = KRoofifood * Xroofifood.TermsSet[t].Parametrs[p];
#if debug
//выводим значение Bbest
Console.Write("Значение Bbest = ");
Console.WriteLine(Bbest[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
//расчитываем значение B
KnowlegeBasePCRules[] B = new KnowlegeBasePCRules[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
B[i] = new KnowlegeBasePCRules(Population[i]);
for (int t = 0; t < B[i].TermsSet.Count; t++)
{
for (int p = 0; p < B[i].TermsSet[t].CountParams; p++)
{
B[i].TermsSet[t].Parametrs[p] = Bfood[i].TermsSet[t].Parametrs[p] + Bbest[i].TermsSet[t].Parametrs[p];
#if debug
//выводим значение B
Console.Write("Значение __B__ = ");
Console.WriteLine(B[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
//расчитываем значение F
KnowlegeBasePCRules[] F = new KnowlegeBasePCRules[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
if (i == 0)
{
F[i] = new KnowlegeBasePCRules(Population[i]);
for (int t = 0; t < F[i].TermsSet.Count; t++)
{
for (int p = 0; p < F[i].TermsSet[t].CountParams; p++)
{
F[i].TermsSet[t].Parametrs[p] = Vf * B[i].TermsSet[t].Parametrs[p];
#if debug
//выводим значение F
Console.Write("Значение __F__ = ");
Console.WriteLine(F[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
else
{
F[i] = new KnowlegeBasePCRules(Population[i]);
for (int t = 0; t < F[i].TermsSet.Count; t++)
{
for (int p = 0; p < F[i].TermsSet[t].CountParams; p++)
{
F[i].TermsSet[t].Parametrs[p] = Vf * B[i].TermsSet[t].Parametrs[p] + wf * F[i - 1].TermsSet[t].Parametrs[p];
#if debug
//выводим значение F
Console.Write("Значение __F__ = ");
Console.WriteLine(F[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
}
List <int> [] neihbors = new List <int> [Population.Length];
//расчитываем значение alocal
KnowlegeBasePCRules[] alocal = new KnowlegeBasePCRules[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
alocal[i] = new KnowlegeBasePCRules(Population[i]);
neihbors[i] = countneihbors(Population[i]);
/*
#if debug
* //вывод значений количества соседей
* for (int g = 0; g < Population.Length; g++)
* {
* Console.Write("Знаение countneihbors = ");
* Console.WriteLine(countneihbors(Population[g]));
* }
#endif
*/
for (int t = 0; t < alocal[i].TermsSet.Count; t++)
{
for (int p = 0; p < alocal[i].TermsSet[t].CountParams; p++)
{
alocal[i].TermsSet[t].Parametrs[p] = 0;
for (int j = 0; j < neihbors[i].Count; j++)
{
double KRoofij = CalcKroof(K[i], K[neihbors[i][j]]);
KnowlegeBasePCRules XRoofij = new KnowlegeBasePCRules(CalcXroof(Population[i], Population[neihbors[i][j]]));
alocal[i].TermsSet[t].Parametrs[p] += KRoofij * XRoofij.TermsSet[t].Parametrs[p];
#if debug
//выводим значение alocal
Console.Write("Знаение alocal = ");
Console.WriteLine(alocal[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
}
//расчитываем значение Cbest
double Cbest = 2 * (rand.NextDouble() - (dit / diter));
#if debug
//выводим значение Cbest
Console.Write("Значение Сbest = ");
Console.WriteLine(Cbest);
#endif
//расчитываем значение rand для Cbest
double rand2;
rand2 = it / iter - Cbest / 2;
#if debug
//выводим значение rand2 для Cbest
Console.Write("Значение Crand = ");
Console.WriteLine(rand2);
#endif
//расчитываем значение atarget
KnowlegeBasePCRules[] atarget = new KnowlegeBasePCRules[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
atarget[i] = new KnowlegeBasePCRules(Population[i]);
double KRoofibest = CalcKroof(K[i], K[ibest]);
KnowlegeBasePCRules XRoofibest = new KnowlegeBasePCRules(CalcXroof(Population[i], Population[ibest]));
for (int t = 0; t < alocal[i].TermsSet.Count; t++)
{
for (int p = 0; p < atarget[i].TermsSet[t].CountParams; p++)
{
atarget[i].TermsSet[t].Parametrs[p] = Cbest * KRoofibest * XRoofibest.TermsSet[t].Parametrs[p];
#if debug
//выводим значение atarget
Console.Write("Знание atarget = ");
Console.WriteLine(atarget[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
//расчитываем значение a
KnowlegeBasePCRules[] a = new KnowlegeBasePCRules[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
a[i] = new KnowlegeBasePCRules(Population[i]);
for (int t = 0; t < a[i].TermsSet.Count; t++)
{
for (int p = 0; p < a[i].TermsSet[t].CountParams; p++)
{
a[i].TermsSet[t].Parametrs[p] = atarget[i].TermsSet[t].Parametrs[p] + alocal[i].TermsSet[t].Parametrs[p];
#if debug
//выводим значение a
Console.Write("Значение __a__ = ");
Console.WriteLine(a[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
//расчитываем значение N
KnowlegeBasePCRules[] N = new KnowlegeBasePCRules[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
if (i == 0)
{
N[i] = new KnowlegeBasePCRules(Population[i]);
for (int t = 0; t < N[i].TermsSet.Count; t++)
{
for (int p = 0; p < F[i].TermsSet[t].CountParams; p++)
{
N[i].TermsSet[t].Parametrs[p] = Vf * a[i].TermsSet[t].Parametrs[p];
#if debug
//выводим значение N
Console.Write("Значение __N__ = ");
Console.WriteLine(N[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
else
{
N[i] = new KnowlegeBasePCRules(Population[i]);
for (int t = 0; t < F[i].TermsSet.Count; t++)
{
for (int p = 0; p < N[i].TermsSet[t].CountParams; p++)
{
N[i].TermsSet[t].Parametrs[p] = nmax * a[i].TermsSet[t].Parametrs[p] + wn * N[i - 1].TermsSet[t].Parametrs[p];
#if debug
//выводим значение N
Console.Write("Значение __N__ = ");
Console.WriteLine(N[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
}
//расчитываем значение dX
KnowlegeBasePCRules[] dX = new KnowlegeBasePCRules[Population.Length];
for (int i = 0; i < Population.Length; i++)
{
dX[i] = new KnowlegeBasePCRules(Population[i]);
for (int t = 0; t < a[i].TermsSet.Count; t++)
{
for (int p = 0; p < a[i].TermsSet[t].CountParams; p++)
{
dX[i].TermsSet[t].Parametrs[p] = F[i].TermsSet[t].Parametrs[p] + N[i].TermsSet[t].Parametrs[p] + D;
#if debug
//выводим значение dX
Console.Write("Значение _dX__ = ");
Console.WriteLine(dX[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
//выводим значение BEST
// Console.Write("Значение BEST_ = ");
// Console.WriteLine(BEST);
//расчитываем значение X(t+dt)
for (int i = 0; i < Population.Length; i++)
{
Population[i] = new KnowlegeBasePCRules(Population[i]);
for (int t = 0; t < Population[i].TermsSet.Count; t++)
{
for (int p = 0; p < F[i].TermsSet[t].CountParams; p++)
{
Population[i].TermsSet[t].Parametrs[p] = Population[i].TermsSet[t].Parametrs[p] + calcdeltat(ct) * dX[i].TermsSet[t].Parametrs[p];
#if debug
//выводим значение Xnew
Console.Write("Знание X(t+dt) = ");
Console.WriteLine(Population[i].TermsSet[t].Parametrs[p]);
#endif
}
}
}
for (int i = 0; i < Population.Length; i++)
{
double temp = result.ErrorLearnSamples(Population[i]);
if (double.IsNaN(temp) || double.IsInfinity(temp))
{
result.UnlaidProtectionFix(Xfood);
temp = result.ErrorLearnSamples(Population[i]);
}
if (temp < bestError)
{
BEST = new KnowlegeBasePCRules(Population[i]);
bestError = temp;
}
}
double y = it;
if (y % 10 == 0 & y != 0)
{
Console.WriteLine(it);
Console.WriteLine(bestError);
}
#if debug
// выводим значение лучшей ошибки Kbest
Console.Write("Значние BestError = ");
Console.WriteLine(bestError);
Console.WriteLine(".");
#endif
}
result.RulesDatabaseSet[0] = BEST;
return(result);
}
